@rootnative/impulse 0.0.0-alpha.0 → 0.0.0-alpha.1

package/dist/{chunk-PMR25UCT.js → chunk-HGBCIL6X.js}

@@ -1,4 +1,4 @@
-import { useGestureMemo } from './chunk-F4RHM4ZK.js';
+import { useGestureMemo } from './chunk-NYDDZD4G.js';
 
 // src/raw/useRawGesture.ts
 function useRawGesture(build, deps, options) {

package/dist/chunk-HI5PHDJY.js

@@ -0,0 +1,94 @@
+import { useStableRecord, useLatestCallback, buildIntentResult } from './chunk-2UZTAWUQ.js';
+import { useGestureMemo } from './chunk-NYDDZD4G.js';
+import { useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+import { useSharedValue } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
+
+var DEFAULT_MIN_DURATION = 500;
+var DEFAULT_MAX_DISTANCE = 10;
+function toLongPressEvent(event) {
+  "worklet";
+  return {
+    x: event.x,
+    y: event.y,
+    absolute: { x: event.absoluteX, y: event.absoluteY },
+    duration: event.duration,
+    pointers: event.numberOfPointers
+  };
+}
+function useLongPress(options = {}) {
+  const {
+    minDuration = DEFAULT_MIN_DURATION,
+    maxDistance = DEFAULT_MAX_DISTANCE,
+    pointers,
+    enabled,
+    onLongPress,
+    onLongPressEnd,
+    onBegin,
+    onFinalize
+  } = options;
+  const isActive = useSharedValue(false);
+  const hitSlop = useStableRecord(options.hitSlop);
+  const handleLongPress = useLatestCallback(onLongPress);
+  const handleLongPressEnd = useLatestCallback(onLongPressEnd);
+  const hasLongPress = onLongPress !== void 0;
+  const hasLongPressEnd = onLongPressEnd !== void 0;
+  const built = useGestureMemo(
+    "useLongPress",
+    () => {
+      const press = Gesture.LongPress().minDuration(minDuration).maxDistance(maxDistance).onBegin((event) => {
+        "worklet";
+        onBegin?.(toLongPressEvent(event));
+      }).onStart((event) => {
+        "worklet";
+        isActive.value = true;
+        if (hasLongPress) {
+          scheduleOnRN(handleLongPress, toLongPressEvent(event));
+        }
+      }).onEnd((event, success) => {
+        "worklet";
+        if (hasLongPressEnd) {
+          scheduleOnRN(handleLongPressEnd, toLongPressEvent(event), {
+            cancelled: !success
+          });
+        }
+      }).onFinalize((event, success) => {
+        "worklet";
+        isActive.value = false;
+        onFinalize?.(toLongPressEvent(event), success);
+      });
+      if (pointers !== void 0) {
+        press.numberOfPointers(pointers);
+      }
+      if (hitSlop !== void 0) {
+        press.hitSlop(hitSlop);
+      }
+      if (enabled !== void 0) {
+        press.enabled(enabled);
+      }
+      return press;
+    },
+    [
+      minDuration,
+      maxDistance,
+      pointers,
+      hitSlop,
+      enabled,
+      hasLongPress,
+      hasLongPressEnd,
+      handleLongPress,
+      handleLongPressEnd,
+      isActive,
+      onBegin,
+      onFinalize
+    ],
+    options
+  );
+  return useMemo(
+    () => buildIntentResult(built, { isActive }),
+    [built, isActive]
+  );
+}
+
+export { useLongPress };

package/dist/{chunk-IG5RXCYR.js → chunk-IH7SQ5X6.js}

@@ -1,20 +1,13 @@
-import { useStableRecord, useLatestCallback } from './chunk-5BMRKYVY.js';
-import { useGestureMemo } from './chunk-F4RHM4ZK.js';
+import { toTapEvent } from './chunk-VEPUHGPN.js';
+import { useStableRecord, useLatestCallback, buildIntentResult } from './chunk-2UZTAWUQ.js';
+import { useGestureMemo } from './chunk-NYDDZD4G.js';
 import { useMemo } from 'react';
 import { Gesture } from 'react-native-gesture-handler';
-import { useSharedValue, runOnJS } from 'react-native-reanimated';
+import { useSharedValue } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
 
 var DEFAULT_MAX_DURATION = 500;
 var DEFAULT_MAX_DISTANCE = 10;
-function toTapEvent(event) {
-  "worklet";
-  return {
-    x: event.x,
-    y: event.y,
-    absolute: { x: event.absoluteX, y: event.absoluteY },
-    pointers: event.numberOfPointers
-  };
-}
 function useTap(options = {}) {
   const {
     pointers = 1,
@@ -38,8 +31,8 @@ function useTap(options = {}) {
         onBegin?.(toTapEvent(event));
       }).onEnd((event, success) => {
         "worklet";
-        if (success && hasTapHandler) {
-          runOnJS(handleTap)(toTapEvent(event));
+        if (hasTapHandler) {
+          scheduleOnRN(handleTap, toTapEvent(event), { cancelled: !success });
         }
       }).onFinalize((event, success) => {
         "worklet";
@@ -68,7 +61,10 @@ function useTap(options = {}) {
     ],
     options
   );
-  return useMemo(() => ({ ...built, isActive }), [built, isActive]);
+  return useMemo(
+    () => buildIntentResult(built, { isActive }),
+    [built, isActive]
+  );
 }
 
 export { useTap };

package/dist/chunk-MWCIEVTA.js

@@ -0,0 +1,199 @@
+import { useStableRecord, useLatestCallback, buildIntentResult } from './chunk-2UZTAWUQ.js';
+import { useGestureMemo } from './chunk-NYDDZD4G.js';
+import { useStableList } from './chunk-ZX7WNICB.js';
+import { useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+import { useSharedValue } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
+
+var DEFAULT_THRESHOLD = 10;
+var DEFAULT_COMMIT_DISTANCE = 80;
+var DEFAULT_COMMIT_SPEED = 800;
+var ALL_DIRECTIONS = [
+  "left",
+  "right",
+  "up",
+  "down"
+];
+function pickDirection(translationX, translationY, velocityX, velocityY, commitDistance, commitSpeed, allowLeft, allowRight, allowUp, allowDown) {
+  "worklet";
+  const distanceX = Math.abs(translationX);
+  const distanceY = Math.abs(translationY);
+  if (distanceX >= distanceY) {
+    if (distanceX < commitDistance && Math.abs(velocityX) < commitSpeed) {
+      return null;
+    }
+    if (translationX < 0) {
+      return allowLeft ? "left" : null;
+    }
+    if (translationX > 0) {
+      return allowRight ? "right" : null;
+    }
+    return null;
+  }
+  if (distanceY < commitDistance && Math.abs(velocityY) < commitSpeed) {
+    return null;
+  }
+  if (translationY < 0) {
+    return allowUp ? "up" : null;
+  }
+  if (translationY > 0) {
+    return allowDown ? "down" : null;
+  }
+  return null;
+}
+function useSwipe(options = {}) {
+  const {
+    threshold = DEFAULT_THRESHOLD,
+    commitDistance = DEFAULT_COMMIT_DISTANCE,
+    commitSpeed = DEFAULT_COMMIT_SPEED,
+    failOffset,
+    pointers,
+    enabled,
+    onSwipe,
+    onSwipeEnd,
+    onBegin,
+    onUpdate,
+    onFinalize
+  } = options;
+  const x = useSharedValue(0);
+  const y = useSharedValue(0);
+  const isActive = useSharedValue(false);
+  const originX = useSharedValue(0);
+  const originY = useSharedValue(0);
+  const hitSlop = useStableRecord(options.hitSlop);
+  const directions = useStableList(options.directions ?? ALL_DIRECTIONS);
+  const allowLeft = directions.includes("left");
+  const allowRight = directions.includes("right");
+  const allowUp = directions.includes("up");
+  const allowDown = directions.includes("down");
+  const hasHorizontal = allowLeft || allowRight;
+  const hasVertical = allowUp || allowDown;
+  const axis = hasHorizontal && !hasVertical ? "x" : hasVertical && !hasHorizontal ? "y" : null;
+  const handleSwipe = useLatestCallback(onSwipe);
+  const handleSwipeEnd = useLatestCallback(onSwipeEnd);
+  const hasSwipe = onSwipe !== void 0;
+  const hasSwipeEnd = onSwipeEnd !== void 0;
+  const built = useGestureMemo(
+    "useSwipe",
+    () => {
+      const toSwipeEvent = (event, direction) => {
+        "worklet";
+        const translationX = x.value;
+        const translationY = y.value;
+        const horizontal = Math.abs(translationX) >= Math.abs(translationY);
+        return {
+          direction,
+          distance: Math.abs(horizontal ? translationX : translationY),
+          speed: Math.abs(horizontal ? event.velocityX : event.velocityY),
+          translation: { x: translationX, y: translationY },
+          velocity: { x: event.velocityX, y: event.velocityY },
+          absolute: { x: event.absoluteX, y: event.absoluteY },
+          pointers: event.numberOfPointers
+        };
+      };
+      const pan = Gesture.Pan().onBegin((event) => {
+        "worklet";
+        onBegin?.(toSwipeEvent(event, null));
+      }).onStart((event) => {
+        "worklet";
+        originX.value = event.translationX;
+        originY.value = event.translationY;
+        x.value = 0;
+        y.value = 0;
+        isActive.value = true;
+      }).onUpdate((event) => {
+        "worklet";
+        x.value = event.translationX - originX.value;
+        y.value = event.translationY - originY.value;
+        onUpdate?.(toSwipeEvent(event, null));
+      }).onEnd((event, success) => {
+        "worklet";
+        const direction = success ? pickDirection(
+          x.value,
+          y.value,
+          event.velocityX,
+          event.velocityY,
+          commitDistance,
+          commitSpeed,
+          allowLeft,
+          allowRight,
+          allowUp,
+          allowDown
+        ) : null;
+        if (direction !== null && hasSwipe) {
+          scheduleOnRN(
+            handleSwipe,
+            toSwipeEvent(event, direction)
+          );
+        }
+        if (hasSwipeEnd) {
+          scheduleOnRN(handleSwipeEnd, toSwipeEvent(event, direction), {
+            cancelled: !success
+          });
+        }
+      }).onFinalize((event, success) => {
+        "worklet";
+        isActive.value = false;
+        onFinalize?.(toSwipeEvent(event, null), success);
+      });
+      if (axis === "x") {
+        pan.activeOffsetX([-threshold, threshold]);
+      } else if (axis === "y") {
+        pan.activeOffsetY([-threshold, threshold]);
+      } else {
+        pan.minDistance(threshold);
+      }
+      if (failOffset !== void 0) {
+        if (axis === "x") {
+          pan.failOffsetY([-failOffset, failOffset]);
+        } else if (axis === "y") {
+          pan.failOffsetX([-failOffset, failOffset]);
+        }
+      }
+      if (pointers !== void 0) {
+        pan.minPointers(pointers).maxPointers(pointers);
+      }
+      if (hitSlop !== void 0) {
+        pan.hitSlop(hitSlop);
+      }
+      if (enabled !== void 0) {
+        pan.enabled(enabled);
+      }
+      return pan;
+    },
+    [
+      axis,
+      threshold,
+      commitDistance,
+      commitSpeed,
+      failOffset,
+      pointers,
+      hitSlop,
+      enabled,
+      allowLeft,
+      allowRight,
+      allowUp,
+      allowDown,
+      hasSwipe,
+      hasSwipeEnd,
+      handleSwipe,
+      handleSwipeEnd,
+      x,
+      y,
+      originX,
+      originY,
+      isActive,
+      onBegin,
+      onUpdate,
+      onFinalize
+    ],
+    options
+  );
+  return useMemo(
+    () => buildIntentResult(built, { x, y, isActive }),
+    [built, x, y, isActive]
+  );
+}
+
+export { useSwipe };

package/dist/{chunk-F4RHM4ZK.js → chunk-NYDDZD4G.js}

@@ -1,5 +1,6 @@
 import { useStableList, isDevBuild, warnOnce } from './chunk-ZX7WNICB.js';
-import { useRef, useMemo } from 'react';
+import { useRef, useMemo, useEffect } from 'react';
+import { isWorkletFunction } from 'react-native-worklets';
 
 // src/relations/index.ts
 var RELATIONS = [
@@ -16,6 +17,37 @@ function applyRelations(gesture, relations, hookName) {
     }
   }
 }
+function hasHandlerTag(candidate) {
+  const tag = candidate.handlerTag;
+  return typeof tag === "number" && tag > 0;
+}
+function isUnresolvable(reference) {
+  if (typeof reference !== "object" || reference === null) {
+    return false;
+  }
+  if (!("current" in reference)) {
+    return false;
+  }
+  const current = reference.current;
+  if (current === null || current === void 0) {
+    return false;
+  }
+  return !hasHandlerTag(current);
+}
+function warnOnUnresolvableReferences(relations, hookName) {
+  if (!isDevBuild()) {
+    return;
+  }
+  for (const [option] of RELATIONS) {
+    if (!relations[option].some(isUnresolvable)) {
+      continue;
+    }
+    warnOnce(
+      `relations:untagged:${hookName}:${option}`,
+      `${hookName} received a \`${option}\` reference to a component that owns no gesture, so gesture-handler dropped the relation. The gesture still works and the two still conflict \u2014 nothing reports it at runtime. React Native's own \`ScrollView\` and \`FlatList\` are the usual cause: they carry no handler tag. Import \`ScrollView\` or \`FlatList\` from \`@rootnative/impulse/gesture-handler\` and put the ref on that component instead.`
+    );
+  }
+}
 function warnOnConflictingRelations(relations, hookName) {
   if (!isDevBuild()) {
     return;
@@ -41,6 +73,22 @@ function warnOnConflictingRelations(relations, hookName) {
     }
   }
 }
+var PHASE_CALLBACKS = ["onBegin", "onUpdate", "onFinalize"];
+function warnOnPlainPhaseCallbacks(callbacks, hookName) {
+  if (!isDevBuild() || typeof isWorkletFunction !== "function") {
+    return;
+  }
+  for (const name of PHASE_CALLBACKS) {
+    const callback = callbacks[name];
+    if (typeof callback !== "function" || isWorkletFunction(callback)) {
+      continue;
+    }
+    warnOnce(
+      `worklets:plain:${hookName}:${name}`,
+      `${hookName} received an \`${name}\` that is not a worklet, and \`${name}\` runs on the UI thread. Add the 'worklet' directive as the first statement of the function. Without it, iOS and Android throw "Tried to synchronously call a Remote Function" when the gesture reaches that phase. For code that must run on the JS thread, such as a React state update, use the hook's intent callback instead.`
+    );
+  }
+}
 
 // src/internal/useGestureMemo.ts
 function useGestureMemo(hookName, build, deps, options) {
@@ -48,6 +96,9 @@ function useGestureMemo(hookName, build, deps, options) {
   const blocks = useStableList(options?.blocks);
   const deferTo = useStableList(options?.deferTo);
   const testId = options?.testId;
+  const onBegin = options?.onBegin;
+  const onUpdate = options?.onUpdate;
+  const onFinalize = options?.onFinalize;
   const ref = useRef(void 0);
   const gesture = useMemo(
     () => {
@@ -71,6 +122,12 @@ function useGestureMemo(hookName, build, deps, options) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [...deps, alongside, blocks, deferTo, testId, hookName]
   );
+  useEffect(() => {
+    warnOnUnresolvableReferences({ alongside, blocks, deferTo }, hookName);
+  }, [alongside, blocks, deferTo, hookName]);
+  useEffect(() => {
+    warnOnPlainPhaseCallbacks({ onBegin, onUpdate, onFinalize }, hookName);
+  }, [onBegin, onUpdate, onFinalize, hookName]);
   return useMemo(() => ({ gesture, ref }), [gesture]);
 }
 

package/dist/chunk-PGOQSKEJ.js

@@ -0,0 +1,144 @@
+import { useStableRecord, useLatestCallback, buildIntentResult } from './chunk-2UZTAWUQ.js';
+import { useGestureMemo } from './chunk-NYDDZD4G.js';
+import { useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+import { useSharedValue } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
+
+var DEFAULT_THRESHOLD = 10;
+function usePan(options = {}) {
+  const {
+    axis = "both",
+    threshold = DEFAULT_THRESHOLD,
+    failOffset,
+    pointers,
+    enabled,
+    onPanStart,
+    onPanEnd,
+    onBegin,
+    onUpdate,
+    onFinalize
+  } = options;
+  const x = useSharedValue(0);
+  const y = useSharedValue(0);
+  const isActive = useSharedValue(false);
+  const originX = useSharedValue(0);
+  const originY = useSharedValue(0);
+  const lastX = useSharedValue(0);
+  const lastY = useSharedValue(0);
+  const hitSlop = useStableRecord(options.hitSlop);
+  const movesX = axis !== "y";
+  const movesY = axis !== "x";
+  const handlePanStart = useLatestCallback(onPanStart);
+  const handlePanEnd = useLatestCallback(onPanEnd);
+  const hasPanStart = onPanStart !== void 0;
+  const hasPanEnd = onPanEnd !== void 0;
+  const built = useGestureMemo(
+    "usePan",
+    () => {
+      const toPanEvent = (event, changeX, changeY) => {
+        "worklet";
+        return {
+          translation: { x: x.value, y: y.value },
+          change: { x: changeX, y: changeY },
+          velocity: { x: event.velocityX, y: event.velocityY },
+          absolute: { x: event.absoluteX, y: event.absoluteY },
+          pointers: event.numberOfPointers
+        };
+      };
+      const pan = Gesture.Pan().onBegin((event) => {
+        "worklet";
+        onBegin?.(toPanEvent(event, 0, 0));
+      }).onStart((event) => {
+        "worklet";
+        originX.value = event.translationX;
+        originY.value = event.translationY;
+        lastX.value = 0;
+        lastY.value = 0;
+        x.value = 0;
+        y.value = 0;
+        isActive.value = true;
+        if (hasPanStart) {
+          scheduleOnRN(handlePanStart, toPanEvent(event, 0, 0));
+        }
+      }).onUpdate((event) => {
+        "worklet";
+        const nextX = movesX ? event.translationX - originX.value : 0;
+        const nextY = movesY ? event.translationY - originY.value : 0;
+        const changeX = nextX - lastX.value;
+        const changeY = nextY - lastY.value;
+        lastX.value = nextX;
+        lastY.value = nextY;
+        x.value = nextX;
+        y.value = nextY;
+        onUpdate?.(toPanEvent(event, changeX, changeY));
+      }).onEnd((event, success) => {
+        "worklet";
+        if (hasPanEnd) {
+          scheduleOnRN(handlePanEnd, toPanEvent(event, 0, 0), {
+            cancelled: !success
+          });
+        }
+      }).onFinalize((event, success) => {
+        "worklet";
+        isActive.value = false;
+        onFinalize?.(toPanEvent(event, 0, 0), success);
+      });
+      if (axis === "x") {
+        pan.activeOffsetX([-threshold, threshold]);
+      } else if (axis === "y") {
+        pan.activeOffsetY([-threshold, threshold]);
+      } else {
+        pan.minDistance(threshold);
+      }
+      if (failOffset !== void 0) {
+        if (axis === "x") {
+          pan.failOffsetY([-failOffset, failOffset]);
+        } else if (axis === "y") {
+          pan.failOffsetX([-failOffset, failOffset]);
+        }
+      }
+      if (pointers !== void 0) {
+        pan.minPointers(pointers).maxPointers(pointers);
+      }
+      if (hitSlop !== void 0) {
+        pan.hitSlop(hitSlop);
+      }
+      if (enabled !== void 0) {
+        pan.enabled(enabled);
+      }
+      return pan;
+    },
+    [
+      axis,
+      threshold,
+      failOffset,
+      pointers,
+      hitSlop,
+      enabled,
+      movesX,
+      movesY,
+      hasPanStart,
+      hasPanEnd,
+      handlePanStart,
+      handlePanEnd,
+      x,
+      y,
+      originX,
+      originY,
+      lastX,
+      lastY,
+      isActive,
+      onBegin,
+      onUpdate,
+      onFinalize
+    ],
+    options
+  );
+  return useMemo(
+    () => buildIntentResult(built, { x, y, isActive }),
+    [built, x, y, isActive]
+  );
+}
+
+export { usePan };

package/dist/{chunk-FR242SUF.js → chunk-TGOGIZDH.js}

@@ -1,8 +1,9 @@
-import { useStableRecord, useLatestCallback } from './chunk-5BMRKYVY.js';
-import { useGestureMemo } from './chunk-F4RHM4ZK.js';
+import { useStableRecord, useLatestCallback, buildIntentResult } from './chunk-2UZTAWUQ.js';
+import { useGestureMemo } from './chunk-NYDDZD4G.js';
 import { useMemo } from 'react';
 import { Gesture } from 'react-native-gesture-handler';
-import { useSharedValue, runOnJS } from 'react-native-reanimated';
+import { useSharedValue } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
 
 var DEFAULT_THRESHOLD = 10;
 function resist(value, min, max, elastic) {
@@ -83,7 +84,7 @@ function useDrag(options = {}) {
         startY.value = y.value - event.translationY;
         isActive.value = true;
         if (hasDragStart) {
-          runOnJS(handleDragStart)(toDragEvent(event));
+          scheduleOnRN(handleDragStart, toDragEvent(event));
         }
       }).onUpdate((event) => {
         "worklet";
@@ -106,8 +107,10 @@ function useDrag(options = {}) {
         onUpdate?.(toDragEvent(event));
       }).onEnd((event, success) => {
         "worklet";
-        if (success && hasDragEnd) {
-          runOnJS(handleDragEnd)(toDragEvent(event));
+        if (hasDragEnd) {
+          scheduleOnRN(handleDragEnd, toDragEvent(event), {
+            cancelled: !success
+          });
         }
       }).onFinalize((event, success) => {
         "worklet";
@@ -168,7 +171,10 @@ function useDrag(options = {}) {
     ],
     options
   );
-  return useMemo(() => ({ ...built, x, y, isActive }), [built, x, y, isActive]);
+  return useMemo(
+    () => buildIntentResult(built, { x, y, isActive }),
+    [built, x, y, isActive]
+  );
 }
 
 export { useDrag };

package/dist/chunk-VEPUHGPN.js

@@ -0,0 +1,12 @@
+// src/intents/tapEvent.ts
+function toTapEvent(event) {
+  "worklet";
+  return {
+    x: event.x,
+    y: event.y,
+    absolute: { x: event.absoluteX, y: event.absoluteY },
+    pointers: event.numberOfPointers
+  };
+}
+
+export { toTapEvent };