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

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

@@ -0,0 +1,268 @@
+// Spelling two: `usePanGesture` / `useTapGesture` / `useLongPressGesture`,
+// the hooks.
+//
+// The replacement upstream is migrating to — a 6,763-line tree of hooks that
+// deprecated all twelve builder statics in 3.1.0. Nothing here reimplements
+// the recognizer; it normalises a config object onto the same
+// `RecognizerConfig` the builder writes and returns the same `GestureSpec`.
+// That the file is this short is the evidence that the internal shape was
+// picked correctly: upstream had to rewrite its internals for this migration
+// because its builder WAS its internals.
+//
+// Four real differences from the builder spelling, all upstream's:
+//   - `onStart` is `onActivate`, `onEnd` is `onDeactivate`;
+//   - `onTouchesCancelled` is `onTouchesCancel`, and the touch callbacks take
+//     the event alone, with no state manager;
+//   - the ending callbacks take one argument, and read `canceled` off the
+//     event rather than a second `success` parameter;
+//   - there is no `onChange` at all — `changeX`/`changeY` are always on the
+//     update payload instead.
+import { exclusiveGestures, raceGestures, simultaneousGestures, } from "./composition";
+const asList = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    return Array.isArray(value) ? value : [value];
+};
+/**
+ * Upstream's dev-time validation, reproduced because both messages describe
+ * configs that look reasonable and silently never activate.
+ */
+const validate = (config) => {
+    for (const [name, bound] of [
+        ["activeOffsetX", config.activeOffsetX],
+        ["activeOffsetY", config.activeOffsetY],
+        ["failOffsetX", config.failOffsetX],
+        ["failOffsetY", config.failOffsetY],
+    ]) {
+        if (Array.isArray(bound) && (bound[0] > 0 || bound[1] < 0)) {
+            throw new Error(`react-native-gtkx: first element of ${name} should be negative, ` +
+                "and the second one should be positive.");
+        }
+    }
+    if (config.minDistance === undefined) {
+        return;
+    }
+    if (config.failOffsetX !== undefined || config.failOffsetY !== undefined) {
+        throw new Error("react-native-gtkx: it is not supported to use minDistance with " +
+            "failOffsetX or failOffsetY; use activeOffsetX and activeOffsetY instead.");
+    }
+    if (config.activeOffsetX !== undefined ||
+        config.activeOffsetY !== undefined) {
+        throw new Error("react-native-gtkx: it is not supported to use minDistance with " +
+            "activeOffsetX or activeOffsetY.");
+    }
+};
+/**
+ * Everything the three hooks normalise identically: the common knobs, the
+ * ending callbacks' `canceled` shape, and the touch callbacks' missing state
+ * manager. The per-kind hooks below add their own fields and nothing else.
+ */
+const adaptCommon = (config) => {
+    const normalised = {
+        enabled: config.enabled,
+        hitSlop: config.hitSlop,
+        shouldCancelWhenOutside: config.shouldCancelWhenOutside,
+        manualActivation: config.manualActivation,
+        runOnJS: config.runOnJS,
+        testId: config.testID,
+        onBegin: config.onBegin,
+        onActivate: config.onActivate,
+        // The relations land in the map names, from either spelling. That both
+        // spellings normalise onto one set of lists rather than each carrying its
+        // own is the same claim slice 1 made about the callbacks, tested the same
+        // way: one orchestrator test drives both.
+        simultaneousHandlers: asList(config.simultaneousWith),
+        waitFor: asList(config.requireToFail),
+        blocksHandlers: asList(config.block),
+    };
+    // The ending callbacks are the one place the two spellings disagree about
+    // shape rather than about names: this one reads `canceled` off the event.
+    const { onDeactivate, onFinalize } = config;
+    if (onDeactivate) {
+        normalised.onDeactivate = (event, success) => {
+            onDeactivate({ ...event, canceled: !success });
+        };
+    }
+    if (onFinalize) {
+        normalised.onFinalize = (event, success) => {
+            onFinalize({ ...event, canceled: !success });
+        };
+    }
+    // And the touch callbacks take no state manager in this spelling.
+    const { onTouchesDown, onTouchesMove, onTouchesUp, onTouchesCancel } = config;
+    if (onTouchesDown) {
+        normalised.onTouchesDown = (event) => {
+            onTouchesDown(event);
+        };
+    }
+    if (onTouchesMove) {
+        normalised.onTouchesMove = (event) => {
+            onTouchesMove(event);
+        };
+    }
+    if (onTouchesUp) {
+        normalised.onTouchesUp = (event) => {
+            onTouchesUp(event);
+        };
+    }
+    if (onTouchesCancel) {
+        normalised.onTouchesCancel = (event) => {
+            onTouchesCancel(event);
+        };
+    }
+    return normalised;
+};
+const EMPTY_PAN = {};
+const EMPTY_TAP = {};
+const EMPTY_LONG_PRESS = {};
+const EMPTY_NATIVE = {};
+/**
+ * The hook spelling. Rebuilds its spec every render, exactly as the builder
+ * chained in a component body does, because the callbacks it closes over are
+ * rebuilt every render too — `GestureDetector` reads the config through a ref
+ * rather than resubscribing, which is what makes that free.
+ */
+export const usePanGesture = (config = EMPTY_PAN) => {
+    validate(config);
+    return {
+        kind: "pan",
+        config: {
+            ...adaptCommon(config),
+            activeOffsetX: config.activeOffsetX,
+            activeOffsetY: config.activeOffsetY,
+            failOffsetX: config.failOffsetX,
+            failOffsetY: config.failOffsetY,
+            minDistance: config.minDistance,
+            minVelocity: config.minVelocity,
+            minVelocityX: config.minVelocityX,
+            minVelocityY: config.minVelocityY,
+            minPointers: config.minPointers,
+            maxPointers: config.maxPointers,
+            activateAfterLongPress: config.activateAfterLongPress,
+            onUpdate: config.onUpdate,
+        },
+    };
+};
+/**
+ * `useTapGesture`, the hook spelling of `Gesture.Tap()`.
+ *
+ * `shouldCancelWhenOutside` defaults to true here, matching the builder.
+ * Upstream's own hook does NOT do this even though its builder's constructor
+ * does and its native handler config does — `useLongPressGesture` remembers it
+ * (`transformLongPressProps`) and `useTapGesture` forgets. Two spellings of
+ * one gesture disagreeing about whether a press may wander off the view is a
+ * slip rather than a semantic, and reproducing it would make this module's own
+ * "two spellings, one implementation" claim false.
+ */
+export const useTapGesture = (config = EMPTY_TAP) => ({
+    kind: "tap",
+    config: {
+        ...adaptCommon(config),
+        shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? true,
+        numberOfTaps: config.numberOfTaps,
+        maxDuration: config.maxDuration,
+        maxDelay: config.maxDelay,
+        maxDistance: config.maxDistance,
+        maxDeltaX: config.maxDeltaX,
+        maxDeltaY: config.maxDeltaY,
+        minPointers: config.minPointers,
+    },
+});
+/** `useLongPressGesture`, the hook spelling of `Gesture.LongPress()`. */
+export const useLongPressGesture = (config = EMPTY_LONG_PRESS) => ({
+    kind: "longPress",
+    config: {
+        ...adaptCommon(config),
+        shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? true,
+        minDuration: config.minDuration,
+        maxDistance: config.maxDistance,
+        numberOfPointers: config.numberOfPointers,
+    },
+});
+/** `useNativeGesture`, the hook spelling of `Gesture.Native()`. */
+export const useNativeGesture = (config = EMPTY_NATIVE) => ({
+    kind: "native",
+    config: {
+        ...adaptCommon(config),
+        shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? true,
+        shouldActivateOnStart: config.shouldActivateOnStart,
+        disallowInterruption: config.disallowInterruption,
+        yieldsToContinuousGestures: config.yieldsToContinuousGestures,
+        onUpdate: config.onUpdate,
+    },
+});
+const EMPTY_TOUCHPAD = {};
+/**
+ * `usePinchGesture`, the hook spelling of `Gesture.Pinch()` — and the spelling
+ * upstream's own `@deprecated` tag on `Gesture.Pinch()` points at.
+ *
+ * `shouldCancelWhenOutside` defaults to FALSE, matching the builder and
+ * matching `PinchGestureHandler.init`: a pinch is not addressed to a point the
+ * way a tap is, and a focal point that drifts off the view mid-gesture is not
+ * a reason to cancel it.
+ */
+export const usePinchGesture = (config = EMPTY_TOUCHPAD) => ({
+    kind: "pinch",
+    config: {
+        ...adaptCommon(config),
+        shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? false,
+        onUpdate: config.onUpdate,
+    },
+});
+/** `useRotationGesture`, the hook spelling of `Gesture.Rotation()`. */
+export const useRotationGesture = (config = EMPTY_TOUCHPAD) => ({
+    kind: "rotation",
+    config: {
+        ...adaptCommon(config),
+        shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? false,
+        onUpdate: config.onUpdate,
+    },
+});
+const EMPTY_FLING = {};
+const EMPTY_MANUAL = {};
+const EMPTY_HOVER = {};
+/** `useFlingGesture`, the hook spelling of `Gesture.Fling()`. */
+export const useFlingGesture = (config = EMPTY_FLING) => ({
+    kind: "fling",
+    config: {
+        ...adaptCommon(config),
+        direction: config.direction,
+        numberOfPointers: config.numberOfPointers,
+    },
+});
+/** `useManualGesture`, the hook spelling of `Gesture.Manual()`. */
+export const useManualGesture = (config = EMPTY_MANUAL) => ({
+    kind: "manual",
+    config: {
+        ...adaptCommon(config),
+        onUpdate: config.onUpdate,
+    },
+});
+/** `useHoverGesture`, the hook spelling of `Gesture.Hover()`. */
+export const useHoverGesture = (config = EMPTY_HOVER) => ({
+    kind: "hover",
+    config: {
+        ...adaptCommon(config),
+        hoverEffect: config.effect,
+        onUpdate: config.onUpdate,
+    },
+});
+// There is deliberately NO `useForceTouchGesture`, and that is upstream's own
+// boundary rather than this platform's: `src/v3/hooks/gestures/` has nine
+// directories and no `forceTouch`, `SingleGesture` omits it from its union,
+// and no such hook is exported anywhere in 3.1.0. Inventing one would be the
+// only place in this module where the hook spelling is richer than the
+// spelling it was migrated from. `Gesture.ForceTouch()` is the whole API
+// upstream offers, so it is the whole API offered here.
+// --- the composers, in the hook spelling ---
+//
+// Not hooks in any real sense — upstream's are not either, past a `useMemo`
+// it does not need — and exported under these names because that is what
+// upstream's `src/v3` calls them and what an app migrating off the deprecated
+// statics will write. `useCompetingGestures` is `Gesture.Race()` under the
+// better name: the gestures compete, and they would have anyway.
+export const useCompetingGestures = (...gestures) => raceGestures(...gestures);
+export const useSimultaneousGestures = (...gestures) => simultaneousGestures(...gestures);
+export const useExclusiveGestures = (...gestures) => exclusiveGestures(...gestures);
+//# sourceMappingURL=hooks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/hooks.ts"],"names":[],"mappings":"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","sourcesContent":["// Spelling two: `usePanGesture` / `useTapGesture` / `useLongPressGesture`,\n// the hooks.\n//\n// The replacement upstream is migrating to — a 6,763-line tree of hooks that\n// deprecated all twelve builder statics in 3.1.0. Nothing here reimplements\n// the recognizer; it normalises a config object onto the same\n// `RecognizerConfig` the builder writes and returns the same `GestureSpec`.\n// That the file is this short is the evidence that the internal shape was\n// picked correctly: upstream had to rewrite its internals for this migration\n// because its builder WAS its internals.\n//\n// Four real differences from the builder spelling, all upstream's:\n//   - `onStart` is `onActivate`, `onEnd` is `onDeactivate`;\n//   - `onTouchesCancelled` is `onTouchesCancel`, and the touch callbacks take\n//     the event alone, with no state manager;\n//   - the ending callbacks take one argument, and read `canceled` off the\n//     event rather than a second `success` parameter;\n//   - there is no `onChange` at all — `changeX`/`changeY` are always on the\n//     update payload instead.\nimport {\n  exclusiveGestures,\n  raceGestures,\n  simultaneousGestures,\n} from \"./composition\"\nimport type {\n  AnyGestureSpec,\n  ComposedGestureSpec,\n  GestureEndEventPayload,\n  GestureEventPayload,\n  GestureHitSlop,\n  GestureRef,\n  GestureSpec,\n  GestureTouchEvent,\n  OffsetBound,\n  RecognizerConfig,\n} from \"./types\"\n\n/**\n * The relations, in the hook spelling's names.\n *\n * The same three lists the builder's three methods write, renamed and moved\n * into the config object — `simultaneousWithExternalGesture` is\n * `simultaneousWith`, `requireExternalGestureToFail` is `requireToFail`, and\n * `blocksExternalGesture` is `block`. One gesture or several, because\n * upstream accepts both and an app writing one should not have to wrap it.\n */\ntype RelationHookConfig = {\n  simultaneousWith?: GestureRef | GestureRef[]\n  requireToFail?: GestureRef | GestureRef[]\n  block?: GestureRef | GestureRef[]\n}\n\n/** What every hook spelling accepts, which is upstream's `CommonGestureConfig`. */\ntype CommonGestureHookConfig = RelationHookConfig & {\n  enabled?: boolean\n  hitSlop?: GestureHitSlop\n  shouldCancelWhenOutside?: boolean\n  manualActivation?: boolean\n  runOnJS?: boolean\n  testID?: string\n  onBegin?: (event: GestureEventPayload) => void\n  onActivate?: (event: GestureEventPayload) => void\n  onDeactivate?: (event: GestureEndEventPayload) => void\n  onFinalize?: (event: GestureEndEventPayload) => void\n  onTouchesDown?: (event: GestureTouchEvent) => void\n  onTouchesMove?: (event: GestureTouchEvent) => void\n  onTouchesUp?: (event: GestureTouchEvent) => void\n  onTouchesCancel?: (event: GestureTouchEvent) => void\n}\n\nconst asList = (\n  value: GestureRef | GestureRef[] | undefined,\n): GestureRef[] | undefined => {\n  if (value === undefined) {\n    return undefined\n  }\n  return Array.isArray(value) ? value : [value]\n}\n\n/** The config object `usePanGesture` accepts. */\nexport type PanGestureHookConfig = CommonGestureHookConfig & {\n  activeOffsetX?: OffsetBound\n  activeOffsetY?: OffsetBound\n  failOffsetX?: OffsetBound\n  failOffsetY?: OffsetBound\n  minDistance?: number\n  minVelocity?: number\n  minVelocityX?: number\n  minVelocityY?: number\n  minPointers?: number\n  maxPointers?: number\n  activateAfterLongPress?: number\n  /**\n   * Only a CONTINUOUS gesture has one. Upstream's discrete hooks omit\n   * `onUpdate` from their config type by name (`BaseDiscreteGestureConfig` is\n   * `Omit<…, \"onUpdate\">`), which is the same statement in the other\n   * direction.\n   */\n  onUpdate?: (event: GestureEventPayload) => void\n}\n\n/** The config object `useTapGesture` accepts, in upstream's external names. */\nexport type TapGestureHookConfig = CommonGestureHookConfig & {\n  numberOfTaps?: number\n  maxDuration?: number\n  maxDelay?: number\n  maxDistance?: number\n  maxDeltaX?: number\n  maxDeltaY?: number\n  minPointers?: number\n}\n\n/** The config object `useLongPressGesture` accepts. */\nexport type LongPressGestureHookConfig = CommonGestureHookConfig & {\n  minDuration?: number\n  maxDistance?: number\n  numberOfPointers?: number\n}\n\n/** The config object `useNativeGesture` accepts. */\nexport type NativeGestureHookConfig = CommonGestureHookConfig & {\n  shouldActivateOnStart?: boolean\n  disallowInterruption?: boolean\n  yieldsToContinuousGestures?: boolean\n  /** A native view is continuous upstream, so it reports travel. */\n  onUpdate?: (event: GestureEventPayload) => void\n}\n\n/**\n * The config object `usePinchGesture` and `useRotationGesture` accept.\n *\n * Nothing of their own, and that is upstream's shape rather than an omission:\n * `PinchGestureNativeProperties` and `RotationGestureNativeProperties` are\n * both `Record<string, never>` in 3.1.0's `src/v3`, and the builder classes\n * add no methods either. Both are continuous, so `onUpdate` is here.\n */\nexport type TouchpadGestureHookConfig = CommonGestureHookConfig & {\n  onUpdate?: (event: GestureEventPayload) => void\n}\n\n/**\n * Upstream's dev-time validation, reproduced because both messages describe\n * configs that look reasonable and silently never activate.\n */\nconst validate = (config: PanGestureHookConfig): void => {\n  for (const [name, bound] of [\n    [\"activeOffsetX\", config.activeOffsetX],\n    [\"activeOffsetY\", config.activeOffsetY],\n    [\"failOffsetX\", config.failOffsetX],\n    [\"failOffsetY\", config.failOffsetY],\n  ] as const) {\n    if (Array.isArray(bound) && (bound[0] > 0 || bound[1] < 0)) {\n      throw new Error(\n        `react-native-gtkx: first element of ${name} should be negative, ` +\n          \"and the second one should be positive.\",\n      )\n    }\n  }\n  if (config.minDistance === undefined) {\n    return\n  }\n  if (config.failOffsetX !== undefined || config.failOffsetY !== undefined) {\n    throw new Error(\n      \"react-native-gtkx: it is not supported to use minDistance with \" +\n        \"failOffsetX or failOffsetY; use activeOffsetX and activeOffsetY instead.\",\n    )\n  }\n  if (\n    config.activeOffsetX !== undefined ||\n    config.activeOffsetY !== undefined\n  ) {\n    throw new Error(\n      \"react-native-gtkx: it is not supported to use minDistance with \" +\n        \"activeOffsetX or activeOffsetY.\",\n    )\n  }\n}\n\n/**\n * Everything the three hooks normalise identically: the common knobs, the\n * ending callbacks' `canceled` shape, and the touch callbacks' missing state\n * manager. The per-kind hooks below add their own fields and nothing else.\n */\nconst adaptCommon = (config: CommonGestureHookConfig): RecognizerConfig => {\n  const normalised: RecognizerConfig = {\n    enabled: config.enabled,\n    hitSlop: config.hitSlop,\n    shouldCancelWhenOutside: config.shouldCancelWhenOutside,\n    manualActivation: config.manualActivation,\n    runOnJS: config.runOnJS,\n    testId: config.testID,\n    onBegin: config.onBegin,\n    onActivate: config.onActivate,\n    // The relations land in the map names, from either spelling. That both\n    // spellings normalise onto one set of lists rather than each carrying its\n    // own is the same claim slice 1 made about the callbacks, tested the same\n    // way: one orchestrator test drives both.\n    simultaneousHandlers: asList(config.simultaneousWith),\n    waitFor: asList(config.requireToFail),\n    blocksHandlers: asList(config.block),\n  }\n\n  // The ending callbacks are the one place the two spellings disagree about\n  // shape rather than about names: this one reads `canceled` off the event.\n  const { onDeactivate, onFinalize } = config\n  if (onDeactivate) {\n    normalised.onDeactivate = (event, success) => {\n      onDeactivate({ ...event, canceled: !success })\n    }\n  }\n  if (onFinalize) {\n    normalised.onFinalize = (event, success) => {\n      onFinalize({ ...event, canceled: !success })\n    }\n  }\n\n  // And the touch callbacks take no state manager in this spelling.\n  const { onTouchesDown, onTouchesMove, onTouchesUp, onTouchesCancel } = config\n  if (onTouchesDown) {\n    normalised.onTouchesDown = (event) => {\n      onTouchesDown(event)\n    }\n  }\n  if (onTouchesMove) {\n    normalised.onTouchesMove = (event) => {\n      onTouchesMove(event)\n    }\n  }\n  if (onTouchesUp) {\n    normalised.onTouchesUp = (event) => {\n      onTouchesUp(event)\n    }\n  }\n  if (onTouchesCancel) {\n    normalised.onTouchesCancel = (event) => {\n      onTouchesCancel(event)\n    }\n  }\n\n  return normalised\n}\n\nconst EMPTY_PAN: PanGestureHookConfig = {}\nconst EMPTY_TAP: TapGestureHookConfig = {}\nconst EMPTY_LONG_PRESS: LongPressGestureHookConfig = {}\nconst EMPTY_NATIVE: NativeGestureHookConfig = {}\n\n/**\n * The hook spelling. Rebuilds its spec every render, exactly as the builder\n * chained in a component body does, because the callbacks it closes over are\n * rebuilt every render too — `GestureDetector` reads the config through a ref\n * rather than resubscribing, which is what makes that free.\n */\nexport const usePanGesture = (\n  config: PanGestureHookConfig = EMPTY_PAN,\n): GestureSpec => {\n  validate(config)\n\n  return {\n    kind: \"pan\",\n    config: {\n      ...adaptCommon(config),\n      activeOffsetX: config.activeOffsetX,\n      activeOffsetY: config.activeOffsetY,\n      failOffsetX: config.failOffsetX,\n      failOffsetY: config.failOffsetY,\n      minDistance: config.minDistance,\n      minVelocity: config.minVelocity,\n      minVelocityX: config.minVelocityX,\n      minVelocityY: config.minVelocityY,\n      minPointers: config.minPointers,\n      maxPointers: config.maxPointers,\n      activateAfterLongPress: config.activateAfterLongPress,\n      onUpdate: config.onUpdate,\n    },\n  }\n}\n\n/**\n * `useTapGesture`, the hook spelling of `Gesture.Tap()`.\n *\n * `shouldCancelWhenOutside` defaults to true here, matching the builder.\n * Upstream's own hook does NOT do this even though its builder's constructor\n * does and its native handler config does — `useLongPressGesture` remembers it\n * (`transformLongPressProps`) and `useTapGesture` forgets. Two spellings of\n * one gesture disagreeing about whether a press may wander off the view is a\n * slip rather than a semantic, and reproducing it would make this module's own\n * \"two spellings, one implementation\" claim false.\n */\nexport const useTapGesture = (\n  config: TapGestureHookConfig = EMPTY_TAP,\n): GestureSpec => ({\n  kind: \"tap\",\n  config: {\n    ...adaptCommon(config),\n    shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? true,\n    numberOfTaps: config.numberOfTaps,\n    maxDuration: config.maxDuration,\n    maxDelay: config.maxDelay,\n    maxDistance: config.maxDistance,\n    maxDeltaX: config.maxDeltaX,\n    maxDeltaY: config.maxDeltaY,\n    minPointers: config.minPointers,\n  },\n})\n\n/** `useLongPressGesture`, the hook spelling of `Gesture.LongPress()`. */\nexport const useLongPressGesture = (\n  config: LongPressGestureHookConfig = EMPTY_LONG_PRESS,\n): GestureSpec => ({\n  kind: \"longPress\",\n  config: {\n    ...adaptCommon(config),\n    shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? true,\n    minDuration: config.minDuration,\n    maxDistance: config.maxDistance,\n    numberOfPointers: config.numberOfPointers,\n  },\n})\n\n/** `useNativeGesture`, the hook spelling of `Gesture.Native()`. */\nexport const useNativeGesture = (\n  config: NativeGestureHookConfig = EMPTY_NATIVE,\n): GestureSpec => ({\n  kind: \"native\",\n  config: {\n    ...adaptCommon(config),\n    shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? true,\n    shouldActivateOnStart: config.shouldActivateOnStart,\n    disallowInterruption: config.disallowInterruption,\n    yieldsToContinuousGestures: config.yieldsToContinuousGestures,\n    onUpdate: config.onUpdate,\n  },\n})\n\nconst EMPTY_TOUCHPAD: TouchpadGestureHookConfig = {}\n\n/**\n * `usePinchGesture`, the hook spelling of `Gesture.Pinch()` — and the spelling\n * upstream's own `@deprecated` tag on `Gesture.Pinch()` points at.\n *\n * `shouldCancelWhenOutside` defaults to FALSE, matching the builder and\n * matching `PinchGestureHandler.init`: a pinch is not addressed to a point the\n * way a tap is, and a focal point that drifts off the view mid-gesture is not\n * a reason to cancel it.\n */\nexport const usePinchGesture = (\n  config: TouchpadGestureHookConfig = EMPTY_TOUCHPAD,\n): GestureSpec => ({\n  kind: \"pinch\",\n  config: {\n    ...adaptCommon(config),\n    shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? false,\n    onUpdate: config.onUpdate,\n  },\n})\n\n/** `useRotationGesture`, the hook spelling of `Gesture.Rotation()`. */\nexport const useRotationGesture = (\n  config: TouchpadGestureHookConfig = EMPTY_TOUCHPAD,\n): GestureSpec => ({\n  kind: \"rotation\",\n  config: {\n    ...adaptCommon(config),\n    shouldCancelWhenOutside: config.shouldCancelWhenOutside ?? false,\n    onUpdate: config.onUpdate,\n  },\n})\n\n/**\n * The config object `useFlingGesture` accepts.\n *\n * No `onUpdate`, matching upstream: `FlingGestureInternalConfig` is a\n * `BaseDiscreteGestureConfig`, which omits it by name. A fling activates and\n * ends in one breath and has nothing to update with.\n */\nexport type FlingGestureHookConfig = CommonGestureHookConfig & {\n  direction?: number\n  numberOfPointers?: number\n}\n\n/** The config object `useManualGesture` accepts, which is only the common one. */\nexport type ManualGestureHookConfig = CommonGestureHookConfig & {\n  onUpdate?: (event: GestureEventPayload) => void\n}\n\n/** The config object `useHoverGesture` accepts. */\nexport type HoverGestureHookConfig = CommonGestureHookConfig & {\n  /**\n   * iOS's own pointer effect. Upstream's hook maps `effect` onto the native\n   * `hoverEffect` prop; both names arrive at the same inert field here.\n   */\n  effect?: number\n  onUpdate?: (event: GestureEventPayload) => void\n}\n\nconst EMPTY_FLING: FlingGestureHookConfig = {}\nconst EMPTY_MANUAL: ManualGestureHookConfig = {}\nconst EMPTY_HOVER: HoverGestureHookConfig = {}\n\n/** `useFlingGesture`, the hook spelling of `Gesture.Fling()`. */\nexport const useFlingGesture = (\n  config: FlingGestureHookConfig = EMPTY_FLING,\n): GestureSpec => ({\n  kind: \"fling\",\n  config: {\n    ...adaptCommon(config),\n    direction: config.direction,\n    numberOfPointers: config.numberOfPointers,\n  },\n})\n\n/** `useManualGesture`, the hook spelling of `Gesture.Manual()`. */\nexport const useManualGesture = (\n  config: ManualGestureHookConfig = EMPTY_MANUAL,\n): GestureSpec => ({\n  kind: \"manual\",\n  config: {\n    ...adaptCommon(config),\n    onUpdate: config.onUpdate,\n  },\n})\n\n/** `useHoverGesture`, the hook spelling of `Gesture.Hover()`. */\nexport const useHoverGesture = (\n  config: HoverGestureHookConfig = EMPTY_HOVER,\n): GestureSpec => ({\n  kind: \"hover\",\n  config: {\n    ...adaptCommon(config),\n    hoverEffect: config.effect,\n    onUpdate: config.onUpdate,\n  },\n})\n\n// There is deliberately NO `useForceTouchGesture`, and that is upstream's own\n// boundary rather than this platform's: `src/v3/hooks/gestures/` has nine\n// directories and no `forceTouch`, `SingleGesture` omits it from its union,\n// and no such hook is exported anywhere in 3.1.0. Inventing one would be the\n// only place in this module where the hook spelling is richer than the\n// spelling it was migrated from. `Gesture.ForceTouch()` is the whole API\n// upstream offers, so it is the whole API offered here.\n\n// --- the composers, in the hook spelling ---\n//\n// Not hooks in any real sense — upstream's are not either, past a `useMemo`\n// it does not need — and exported under these names because that is what\n// upstream's `src/v3` calls them and what an app migrating off the deprecated\n// statics will write. `useCompetingGestures` is `Gesture.Race()` under the\n// better name: the gestures compete, and they would have anyway.\n\nexport const useCompetingGestures = (\n  ...gestures: AnyGestureSpec[]\n): ComposedGestureSpec => raceGestures(...gestures)\n\nexport const useSimultaneousGestures = (\n  ...gestures: AnyGestureSpec[]\n): ComposedGestureSpec => simultaneousGestures(...gestures)\n\nexport const useExclusiveGestures = (\n  ...gestures: AnyGestureSpec[]\n): ComposedGestureSpec => exclusiveGestures(...gestures)\n"]}

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

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

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

@@ -0,0 +1,22 @@
+export const hoverDecider = {
+    kind: "hover",
+    // See the header: no press, so no interaction lock to take. Every event
+    // arrives through `Recognizer.controller` instead.
+    claimsResponder: false,
+    source: "hover",
+    /**
+     * Never. A hover has no failure mode of its own — the pointer is either over
+     * the view or it is not, and leaving is an END rather than a failure
+     * (upstream's `onPointerMoveOut` calls `end()`). The controller channel's
+     * own `end` is what reports it.
+     */
+    shouldFail: () => false,
+    /**
+     * Always. The crossing IS the gesture: there is no distance to travel, no
+     * time to wait and nothing to disambiguate it from. Returning a constant is
+     * upstream's `begin(); activate();` on the enter event, stated as the
+     * predicate the shared machine asks for.
+     */
+    shouldActivate: () => true,
+};
+//# sourceMappingURL=hover.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hover.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/hover.ts"],"names":[],"mappings":"AA2DA,MAAM,CAAC,MAAM,YAAY,GAAsB;IAC7C,IAAI,EAAE,OAAO;IAEb,wEAAwE;IACxE,mDAAmD;IACnD,eAAe,EAAE,KAAK;IACtB,MAAM,EAAE,OAAO;IAEf;;;;;OAKG;IACH,UAAU,EAAE,GAAY,EAAE,CAAC,KAAK;IAEhC;;;;;OAKG;IACH,cAAc,EAAE,GAAY,EAAE,CAAC,IAAI;CACpC,CAAA","sourcesContent":["// `Gesture.Hover()` — the pointer being OVER a view, with no button involved.\n//\n// THE REFUSAL THIS REPLACES WAS WRONG, and it is worth writing down why rather\n// than quietly deleting it. `docs/research/gesture-detector.md` grouped `Hover`\n// with `Pinch`/`Rotation`/`ForceTouch` as \"no input to run on\". That was a\n// reasonable reading of a rig whose only injection protocol was\n// `zwlr_virtual_pointer_v1` — but it is the wrong test for this gesture,\n// because a hover needs no protocol the rig lacked. A mouse hovers. The\n// virtual pointer moves a mouse. `motion_absolute` with no `button` request is\n// already a hover, and it always was: `Pressable` has shipped hover on\n// `GtkEventControllerMotion` since long before this epic, and the gallery has\n// hovered rows on screen. The refusal was inherited from its neighbours rather\n// than measured, and measuring it takes one injected move.\n//\n// SO IT IS THE MOST TESTABLE of the four rather than the least: everything\n// here runs under the ordinary headless compositor in the ordinary test suite,\n// with a real pointer and a real crossing, which is more than `Pinch` and\n// `Rotation` can say.\n//\n// WHERE IT COMES FROM. `GtkEventControllerMotion`'s `enter`/`motion`/`leave`,\n// the same controller `components/pressable.tsx` already uses, attached by\n// ./detector-runtime and pumped into `Recognizer.controller`. Not the touch\n// props: those fire from a PRESS, and the defining property of a hover is that\n// there is no press. That is the same reason `Pinch` needed a channel of its\n// own, and it is the same channel.\n//\n// IT NEVER TAKES THE RESPONDER (`claimsResponder: false`), for exactly the\n// structural reason the touchpad kinds do not: the responder lock is a lock\n// over an INTERACTION, an interaction here starts with a press, and a hover\n// has none. There is no session to take, no GTK sequence to claim and nothing\n// to transfer. A hover therefore cannot exclude a press, which is the correct\n// behaviour and also the only reachable one.\n//\n// Restated from `src/web/handlers/HoverGestureHandler.ts` at 3.1.0. Two\n// details are worth naming:\n//\n//   - **it activates on the crossing itself.** `onPointerMoveOver` calls\n//     `begin()` and then `activate()` in the same synchronous breath, so a\n//     hover is BEGAN and ACTIVE within one event and there is no threshold of\n//     any kind. `shouldActivate` returning a constant `true` IS that;\n//   - **no button is consulted anywhere on the path.** Upstream's other\n//     handlers gate `onPointerDown` on `isButtonInConfig`; the three hover\n//     entry points never call it. `mouseButton` is inert for this kind, on\n//     both platforms and for the same reason.\n//\n// UPSTREAM'S DEFAULT IS MUTUAL EXCLUSION AND THAT IS REPRODUCED, which is the\n// one thing to know before putting a hover next to something. A gesture that\n// activates cancels every recorded gesture it is not simultaneous with, and a\n// hover activates whenever the pointer crosses in — so a hover entering while\n// a pan on another view is still BEGAN will cancel that pan. Upstream behaves\n// the same way and works around it per-use: its own `Pressable` sets\n// `manualActivation` on the hover recognizer precisely to stop it blocking a\n// `Gesture.Native()`. Inventing an exemption here would be a second\n// arbitration rule that upstream does not have; declaring\n// `simultaneousWithExternalGesture` is the answer, and it is the answer the\n// relation registry exists to give. docs/api.md says so where an app will\n// read it.\nimport type { RecognizerDecider } from \"./recognizer\"\n\nexport const hoverDecider: RecognizerDecider = {\n  kind: \"hover\",\n\n  // See the header: no press, so no interaction lock to take. Every event\n  // arrives through `Recognizer.controller` instead.\n  claimsResponder: false,\n  source: \"hover\",\n\n  /**\n   * Never. A hover has no failure mode of its own — the pointer is either over\n   * the view or it is not, and leaving is an END rather than a failure\n   * (upstream's `onPointerMoveOut` calls `end()`). The controller channel's\n   * own `end` is what reports it.\n   */\n  shouldFail: (): boolean => false,\n\n  /**\n   * Always. The crossing IS the gesture: there is no distance to travel, no\n   * time to wait and nothing to disambiguate it from. Returning a constant is\n   * upstream's `begin(); activate();` on the enter event, stated as the\n   * predicate the shared machine asks for.\n   */\n  shouldActivate: (): boolean => true,\n}\n"]}

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

@@ -0,0 +1,98 @@
+import type { ReactNode } from "react";
+import type { StyleProp } from "../contracts";
+import { Gesture } from "./builder";
+import { GestureDetector } from "./detector";
+import { useCompetingGestures, useExclusiveGestures, useFlingGesture, useHoverGesture, useLongPressGesture, useManualGesture, useNativeGesture, usePanGesture, usePinchGesture, useRotationGesture, useSimultaneousGestures, useTapGesture } from "./hooks";
+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";
+export type { GestureDetectorProps } from "./detector";
+export type { FlingGestureHookConfig, HoverGestureHookConfig, LongPressGestureHookConfig, ManualGestureHookConfig, NativeGestureHookConfig, PanGestureHookConfig, TapGestureHookConfig, } from "./hooks";
+export type { AnyGestureSpec, ComposedGestureKind, ComposedGestureSpec, GestureEndEventPayload, GestureEventPayload, GestureHitSlop, GestureKind, GestureRef, GestureRelations, GestureSpec, GestureStateManagerApi, GestureTouchData, GestureTouchEvent, OffsetBound, } from "./types";
+export type GestureHandlerRootViewProps = {
+    children?: ReactNode;
+    style?: StyleProp;
+    testID?: string;
+};
+/**
+ * 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 declare const GestureHandlerRootView: ({ children, style, testID, }: GestureHandlerRootViewProps) => ReactNode;
+export declare const FlingGestureHandler: any;
+export declare const ForceTouchGestureHandler: any;
+export declare const LongPressGestureHandler: any;
+export declare const NativeViewGestureHandler: any;
+export declare const PanGestureHandler: any;
+export declare const PinchGestureHandler: any;
+export declare const RotationGestureHandler: any;
+export declare const TapGestureHandler: any;
+export declare const legacy_createNativeWrapper: any;
+export declare const GestureDetectorType: any;
+export declare const GestureStateManager: any;
+export declare const InterceptingGestureDetector: any;
+export declare const VirtualGestureDetector: any;
+export declare const State: {
+    readonly UNDETERMINED: 0;
+    readonly FAILED: 1;
+    readonly BEGAN: 2;
+    readonly CANCELLED: 3;
+    readonly ACTIVE: 4;
+    readonly END: 5;
+};
+export declare const Directions: {
+    readonly RIGHT: 1;
+    readonly LEFT: 2;
+    readonly UP: 4;
+    readonly DOWN: 8;
+};
+export declare const HoverEffect: {
+    readonly NONE: 0;
+    readonly LIFT: 1;
+    readonly HIGHLIGHT: 2;
+};
+export declare const MouseButton: {
+    readonly LEFT: 1;
+    readonly RIGHT: 2;
+    readonly MIDDLE: 4;
+    readonly BUTTON_4: 8;
+    readonly BUTTON_5: 16;
+    readonly ALL: 31;
+};
+export declare const PointerType: {
+    readonly TOUCH: 0;
+    readonly STYLUS: 1;
+    readonly MOUSE: 2;
+    readonly KEY: 3;
+    readonly OTHER: 4;
+};
+export declare const BaseButton: any;
+export declare const BorderlessButton: any;
+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 declare const RawButton: any;
+export declare const RectButton: any;
+export declare const RefreshControl: any;
+export declare const Touchable: any;
+export declare const TouchableNativeFeedback: any;
+export declare const LegacyBaseButton: any;
+export declare const LegacyBorderlessButton: any;
+export declare const LegacyDrawerLayoutAndroid: any;
+export declare const LegacyFlatList: any;
+export declare const LegacyPressable: any;
+export declare const LegacyRawButton: any;
+export declare const LegacyRectButton: any;
+export declare const LegacyRefreshControl: any;
+export declare const LegacyScrollView: any;
+export declare const LegacySwitch: any;
+export declare const LegacyText: any;
+export declare const LegacyTextInput: any;