react-native-screen-transitions 4.1.0-alpha.0 → 4.1.0-beta.1

package/lib/module/providers/screen/motion/gestures/pinch/behavior/pinch-reset.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { FALSE, TRUE } from "../../../../../../constants";
+import { animateMany } from "../../shared/reset";
+import { clearFocalPoint, clearRawTransformValues, clearTransformTrackingValues } from "../../shared/values";
+export const resetPinchGestureValues = ({
+  spec,
+  gestures,
+  animations,
+  shouldDismiss,
+  resetValuesImmediately = false
+}) => {
+  "worklet";
+
+  const finishPinchReset = () => {
+    "worklet";
+
+    if (shouldDismiss) {
+      return;
+    }
+    clearFocalPoint(gestures);
+    gestures.initiator.set(null);
+    gestures.settling.set(FALSE);
+    animations?.progressAnimating.set(FALSE);
+    animations?.progressSettled.set(TRUE);
+  };
+  if (animations && !shouldDismiss) {
+    animations.progressAnimating.set(TRUE);
+    animations.progressSettled.set(FALSE);
+  }
+  clearRawTransformValues(gestures);
+  gestures.dragging.set(FALSE);
+  gestures.dismissing.set(shouldDismiss ? TRUE : FALSE);
+  gestures.settling.set(shouldDismiss ? FALSE : TRUE);
+  if (shouldDismiss) {
+    clearFocalPoint(gestures);
+  }
+  if (resetValuesImmediately) {
+    clearTransformTrackingValues(gestures);
+    finishPinchReset();
+    return;
+  }
+  animateMany([{
+    value: gestures.scale,
+    toValue: 1
+  }, {
+    value: gestures.normScale,
+    toValue: 0
+  }, {
+    value: gestures.rotation,
+    toValue: 0
+  }], spec, finishPinchReset);
+};
+//# sourceMappingURL=pinch-reset.js.map

package/lib/module/providers/screen/motion/gestures/pinch/behavior/pinch-reset.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FALSE","TRUE","animateMany","clearFocalPoint","clearRawTransformValues","clearTransformTrackingValues","resetPinchGestureValues","spec","gestures","animations","shouldDismiss","resetValuesImmediately","finishPinchReset","initiator","set","settling","progressAnimating","progressSettled","dragging","dismissing","value","scale","toValue","normScale","rotation"],"sourceRoot":"../../../../../../../../src","sources":["providers/screen/motion/gestures/pinch/behavior/pinch-reset.ts"],"mappings":";;AAAA,SAASA,KAAK,EAAEC,IAAI,QAAQ,6BAA6B;AAMzD,SAASC,WAAW,QAAQ,oBAAoB;AAChD,SACCC,eAAe,EACfC,uBAAuB,EACvBC,4BAA4B,QACtB,qBAAqB;AAU5B,OAAO,MAAMC,uBAAuB,GAAGA,CAAC;EACvCC,IAAI;EACJC,QAAQ;EACRC,UAAU;EACVC,aAAa;EACbC,sBAAsB,GAAG;AACI,CAAC,KAAK;EACnC,SAAS;;EACT,MAAMC,gBAAgB,GAAGA,CAAA,KAAM;IAC9B,SAAS;;IACT,IAAIF,aAAa,EAAE;MAClB;IACD;IAEAP,eAAe,CAACK,QAAQ,CAAC;IACzBA,QAAQ,CAACK,SAAS,CAACC,GAAG,CAAC,IAAI,CAAC;IAC5BN,QAAQ,CAACO,QAAQ,CAACD,GAAG,CAACd,KAAK,CAAC;IAC5BS,UAAU,EAAEO,iBAAiB,CAACF,GAAG,CAACd,KAAK,CAAC;IACxCS,UAAU,EAAEQ,eAAe,CAACH,GAAG,CAACb,IAAI,CAAC;EACtC,CAAC;EAED,IAAIQ,UAAU,IAAI,CAACC,aAAa,EAAE;IACjCD,UAAU,CAACO,iBAAiB,CAACF,GAAG,CAACb,IAAI,CAAC;IACtCQ,UAAU,CAACQ,eAAe,CAACH,GAAG,CAACd,KAAK,CAAC;EACtC;EAEAI,uBAAuB,CAACI,QAAQ,CAAC;EAEjCA,QAAQ,CAACU,QAAQ,CAACJ,GAAG,CAACd,KAAK,CAAC;EAC5BQ,QAAQ,CAACW,UAAU,CAACL,GAAG,CAACJ,aAAa,GAAGT,IAAI,GAAGD,KAAK,CAAC;EACrDQ,QAAQ,CAACO,QAAQ,CAACD,GAAG,CAACJ,aAAa,GAAGV,KAAK,GAAGC,IAAI,CAAC;EAEnD,IAAIS,aAAa,EAAE;IAClBP,eAAe,CAACK,QAAQ,CAAC;EAC1B;EAEA,IAAIG,sBAAsB,EAAE;IAC3BN,4BAA4B,CAACG,QAAQ,CAAC;IACtCI,gBAAgB,CAAC,CAAC;IAClB;EACD;EAEAV,WAAW,CACV,CACC;IAAEkB,KAAK,EAAEZ,QAAQ,CAACa,KAAK;IAAEC,OAAO,EAAE;EAAE,CAAC,EACrC;IAAEF,KAAK,EAAEZ,QAAQ,CAACe,SAAS;IAAED,OAAO,EAAE;EAAE,CAAC,EACzC;IAAEF,KAAK,EAAEZ,QAAQ,CAACgB,QAAQ;IAAEF,OAAO,EAAE;EAAE,CAAC,CACxC,EACDf,IAAI,EACJK,gBACD,CAAC;AACF,CAAC","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/pinch/behavior/use-pinch-behavior.js

@@ -0,0 +1,45 @@
+"use strict";
+
+import { useCallback, useMemo } from "react";
+import { usePinchGestureSensitivity } from "../../ownership/hooks/use-gesture-sensitivity";
+import { resolvePinchRuntime } from "../../shared/runtime";
+import { finalizePinchRelease, startPinchBase, trackPinchGesture } from "./pinch-lifecycle";
+import { primeSnapPinchRelease, resolvePinchRelease, resolveSnapPinchRelease } from "./pinch-release";
+export const usePinchBehavior = (runtime, screenOptions, gestureCompositionOwner, requestDismiss) => {
+  const {
+    withSensitivity,
+    resetSensitivity
+  } = usePinchGestureSensitivity(screenOptions);
+  const onStart = useCallback(() => {
+    "worklet";
+
+    const latestRuntime = resolvePinchRuntime(runtime.get(), screenOptions.get());
+    if (latestRuntime.participation.effectiveSnapPoints.hasSnapPoints) {
+      primeSnapPinchRelease(latestRuntime);
+    }
+    startPinchBase(latestRuntime);
+    resetSensitivity();
+  }, [runtime, screenOptions, resetSensitivity]);
+  const onUpdate = useCallback(rawEvent => {
+    "worklet";
+
+    const latestRuntime = resolvePinchRuntime(runtime.get(), screenOptions.get());
+    const event = withSensitivity(rawEvent);
+    trackPinchGesture(event, rawEvent, latestRuntime.stores.gestures);
+  }, [runtime, screenOptions, withSensitivity]);
+  const onEnd = useCallback(rawEvent => {
+    "worklet";
+
+    const latestRuntime = resolvePinchRuntime(runtime.get(), screenOptions.get());
+    const event = withSensitivity(rawEvent);
+    const release = latestRuntime.participation.effectiveSnapPoints.hasSnapPoints ? resolveSnapPinchRelease(event, latestRuntime) : resolvePinchRelease(event, latestRuntime);
+    finalizePinchRelease(release, latestRuntime, requestDismiss);
+    gestureCompositionOwner.set(null);
+  }, [runtime, screenOptions, requestDismiss, withSensitivity, gestureCompositionOwner]);
+  return useMemo(() => ({
+    onStart,
+    onUpdate,
+    onEnd
+  }), [onStart, onUpdate, onEnd]);
+};
+//# sourceMappingURL=use-pinch-behavior.js.map

package/lib/module/providers/screen/motion/gestures/pinch/behavior/use-pinch-behavior.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useMemo","usePinchGestureSensitivity","resolvePinchRuntime","finalizePinchRelease","startPinchBase","trackPinchGesture","primeSnapPinchRelease","resolvePinchRelease","resolveSnapPinchRelease","usePinchBehavior","runtime","screenOptions","gestureCompositionOwner","requestDismiss","withSensitivity","resetSensitivity","onStart","latestRuntime","get","participation","effectiveSnapPoints","hasSnapPoints","onUpdate","rawEvent","event","stores","gestures","onEnd","release","set"],"sourceRoot":"../../../../../../../../src","sources":["providers/screen/motion/gestures/pinch/behavior/use-pinch-behavior.ts"],"mappings":";;AAAA,SAASA,WAAW,EAAEC,OAAO,QAAQ,OAAO;AAG5C,SAASC,0BAA0B,QAAQ,+CAA+C;AAC1F,SAASC,mBAAmB,QAAQ,sBAAsB;AAO1D,SACCC,oBAAoB,EACpBC,cAAc,EACdC,iBAAiB,QACX,mBAAmB;AAC1B,SACCC,qBAAqB,EACrBC,mBAAmB,EACnBC,uBAAuB,QACjB,iBAAiB;AAExB,OAAO,MAAMC,gBAAgB,GAAGA,CAC/BC,OAAyC,EACzCC,aAAwC,EACxCC,uBAA6D,EAC7DC,cAA2B,KACR;EACnB,MAAM;IAAEC,eAAe;IAAEC;EAAiB,CAAC,GAC1Cd,0BAA0B,CAACU,aAAa,CAAC;EAE1C,MAAMK,OAAO,GAAGjB,WAAW,CAAC,MAAM;IACjC,SAAS;;IACT,MAAMkB,aAAa,GAAGf,mBAAmB,CACxCQ,OAAO,CAACQ,GAAG,CAAC,CAAC,EACbP,aAAa,CAACO,GAAG,CAAC,CACnB,CAAC;IACD,IAAID,aAAa,CAACE,aAAa,CAACC,mBAAmB,CAACC,aAAa,EAAE;MAClEf,qBAAqB,CAACW,aAAa,CAAC;IACrC;IACAb,cAAc,CAACa,aAAa,CAAC;IAC7BF,gBAAgB,CAAC,CAAC;EACnB,CAAC,EAAE,CAACL,OAAO,EAAEC,aAAa,EAAEI,gBAAgB,CAAC,CAAC;EAE9C,MAAMO,QAAQ,GAAGvB,WAAW,CAC1BwB,QAA2B,IAAK;IAChC,SAAS;;IACT,MAAMN,aAAa,GAAGf,mBAAmB,CACxCQ,OAAO,CAACQ,GAAG,CAAC,CAAC,EACbP,aAAa,CAACO,GAAG,CAAC,CACnB,CAAC;IACD,MAAMM,KAAK,GAAGV,eAAe,CAACS,QAAQ,CAAC;IACvClB,iBAAiB,CAACmB,KAAK,EAAED,QAAQ,EAAEN,aAAa,CAACQ,MAAM,CAACC,QAAQ,CAAC;EAClE,CAAC,EACD,CAAChB,OAAO,EAAEC,aAAa,EAAEG,eAAe,CACzC,CAAC;EAED,MAAMa,KAAK,GAAG5B,WAAW,CACvBwB,QAA2B,IAAK;IAChC,SAAS;;IACT,MAAMN,aAAa,GAAGf,mBAAmB,CACxCQ,OAAO,CAACQ,GAAG,CAAC,CAAC,EACbP,aAAa,CAACO,GAAG,CAAC,CACnB,CAAC;IACD,MAAMM,KAAK,GAAGV,eAAe,CAACS,QAAQ,CAAC;IACvC,MAAMK,OAAO,GAAGX,aAAa,CAACE,aAAa,CAACC,mBAAmB,CAC7DC,aAAa,GACZb,uBAAuB,CAACgB,KAAK,EAAEP,aAAa,CAAC,GAC7CV,mBAAmB,CAACiB,KAAK,EAAEP,aAAa,CAAC;IAC5Cd,oBAAoB,CAACyB,OAAO,EAAEX,aAAa,EAAEJ,cAAc,CAAC;IAC5DD,uBAAuB,CAACiB,GAAG,CAAC,IAAI,CAAC;EAClC,CAAC,EACD,CACCnB,OAAO,EACPC,aAAa,EACbE,cAAc,EACdC,eAAe,EACfF,uBAAuB,CAEzB,CAAC;EAED,OAAOZ,OAAO,CACb,OAAO;IACNgB,OAAO;IACPM,QAAQ;IACRK;EACD,CAAC,CAAC,EACF,CAACX,OAAO,EAAEM,QAAQ,EAAEK,KAAK,CAC1B,CAAC;AACF,CAAC","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/pinch/use-build-pinch-gesture.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import { useMemo } from "react";
+import { Gesture } from "react-native-gesture-handler";
+import { useStableRuntimeConfig } from "../ownership/hooks/use-stable-runtime-config";
+import { usePinchActivation } from "./activation/use-pinch-activation";
+import { usePinchBehavior } from "./behavior/use-pinch-behavior";
+export const useBuildPinchGesture = ({
+  values,
+  onDismissRequest,
+  screenOptions,
+  gestureConfig,
+  gestureCompositionOwner
+}) => {
+  const {
+    participation,
+    pinch: policy
+  } = gestureConfig;
+  const runtime = useStableRuntimeConfig({
+    participation,
+    policy
+  }, values);
+  const activation = usePinchActivation({
+    runtime,
+    screenOptions,
+    gestureCompositionOwner
+  });
+  const behavior = usePinchBehavior(runtime, screenOptions, gestureCompositionOwner, onDismissRequest);
+  const pinchGesture = useMemo(() => {
+    return Gesture.Pinch().enabled(true).manualActivation(true).onTouchesDown(activation.onTouchesDown).onTouchesMove(activation.onTouchesMove).onStart(behavior.onStart).onUpdate(behavior.onUpdate).onEnd(behavior.onEnd);
+  }, [activation, behavior]);
+  return pinchGesture;
+};
+//# sourceMappingURL=use-build-pinch-gesture.js.map

package/lib/module/providers/screen/motion/gestures/pinch/use-build-pinch-gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useMemo","Gesture","useStableRuntimeConfig","usePinchActivation","usePinchBehavior","useBuildPinchGesture","values","onDismissRequest","screenOptions","gestureConfig","gestureCompositionOwner","participation","pinch","policy","runtime","activation","behavior","pinchGesture","Pinch","enabled","manualActivation","onTouchesDown","onTouchesMove","onStart","onUpdate","onEnd"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/pinch/use-build-pinch-gesture.ts"],"mappings":";;AAAA,SAASA,OAAO,QAAQ,OAAO;AAC/B,SAASC,OAAO,QAAQ,8BAA8B;AAItD,SAASC,sBAAsB,QAAQ,8CAA8C;AAMrF,SAASC,kBAAkB,QAAQ,mCAAmC;AACtE,SAASC,gBAAgB,QAAQ,+BAA+B;AAUhE,OAAO,MAAMC,oBAAoB,GAAGA,CAAC;EACpCC,MAAM;EACNC,gBAAgB;EAChBC,aAAa;EACbC,aAAa;EACbC;AAC0B,CAAC,KAAmB;EAC9C,MAAM;IAAEC,aAAa;IAAEC,KAAK,EAAEC;EAAO,CAAC,GAAGJ,aAAa;EAEtD,MAAMK,OAAO,GAAGZ,sBAAsB,CACrC;IACCS,aAAa;IACbE;EACD,CAAC,EACDP,MACD,CAAC;EAED,MAAMS,UAAU,GAAGZ,kBAAkB,CAAC;IACrCW,OAAO;IACPN,aAAa;IACbE;EACD,CAAC,CAAC;EAEF,MAAMM,QAAQ,GAAGZ,gBAAgB,CAChCU,OAAO,EACPN,aAAa,EACbE,uBAAuB,EACvBH,gBACD,CAAC;EAED,MAAMU,YAAY,GAAGjB,OAAO,CAAC,MAAM;IAClC,OAAOC,OAAO,CAACiB,KAAK,CAAC,CAAC,CACpBC,OAAO,CAAC,IAAI,CAAC,CACbC,gBAAgB,CAAC,IAAI,CAAC,CACtBC,aAAa,CAACN,UAAU,CAACM,aAAa,CAAC,CACvCC,aAAa,CAACP,UAAU,CAACO,aAAa,CAAC,CACvCC,OAAO,CAACP,QAAQ,CAACO,OAAO,CAAC,CACzBC,QAAQ,CAACR,QAAQ,CAACQ,QAAQ,CAAC,CAC3BC,KAAK,CAACT,QAAQ,CAACS,KAAK,CAAC;EACxB,CAAC,EAAE,CAACV,UAAU,EAAEC,QAAQ,CAAC,CAAC;EAE1B,OAAOC,YAAY;AACpB,CAAC","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/scroll-coordination/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ScrollMetadataOwnerProvider","useScrollGestureCoordination"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/scroll-coordination/index.ts"],"mappings":";;AAAA,SAASA,2BAA2B,QAAQ,yBAAyB;AACrE,SAASC,4BAA4B,QAAQ,mCAAmC","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/scroll-coordination/scroll-metadata-owner.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import { useMemo } from "react";
+import createProvider from "../../../../../utils/create-provider";
+const DEFAULT_SCROLL_METADATA_OWNER_CONTEXT = {
+  vertical: false,
+  horizontal: false
+};
+export const {
+  ScrollMetadataOwnerProvider,
+  useOptionalScrollMetadataOwnerStore
+} = createProvider("ScrollMetadataOwner")(({
+  children,
+  value
+}) => ({
+  children,
+  value
+}));
+export const useScrollMetadataOwnerProviderValue = axis => {
+  const parent = useOptionalScrollMetadataOwnerStore() ?? DEFAULT_SCROLL_METADATA_OWNER_CONTEXT;
+  return useMemo(() => {
+    if (parent[axis]) return parent;
+    return {
+      ...parent,
+      [axis]: true
+    };
+  }, [axis, parent]);
+};
+//# sourceMappingURL=scroll-metadata-owner.js.map

package/lib/module/providers/screen/motion/gestures/scroll-coordination/scroll-metadata-owner.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useMemo","createProvider","DEFAULT_SCROLL_METADATA_OWNER_CONTEXT","vertical","horizontal","ScrollMetadataOwnerProvider","useOptionalScrollMetadataOwnerStore","children","value","useScrollMetadataOwnerProviderValue","axis","parent"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/scroll-coordination/scroll-metadata-owner.tsx"],"mappings":";;AAAA,SAAyBA,OAAO,QAAQ,OAAO;AAC/C,OAAOC,cAAc,MAAM,sCAAsC;AAUjE,MAAMC,qCAAsE,GAAG;EAC9EC,QAAQ,EAAE,KAAK;EACfC,UAAU,EAAE;AACb,CAAC;AAED,OAAO,MAAM;EACZC,2BAA2B;EAC3BC;AACD,CAAC,GAAGL,cAAc,CAAC,qBAAqB,CAAC,CAGvC,CAAC;EAAEM,QAAQ;EAAEC;AAAM,CAAC,MAAM;EAAED,QAAQ;EAAEC;AAAM,CAAC,CAAC,CAAC;AAEjD,OAAO,MAAMC,mCAAmC,GAC/CC,IAAuB,IACnB;EACJ,MAAMC,MAAM,GACXL,mCAAmC,CAAC,CAAC,IACrCJ,qCAAqC;EAEtC,OAAOF,OAAO,CAAC,MAAM;IACpB,IAAIW,MAAM,CAACD,IAAI,CAAC,EAAE,OAAOC,MAAM;IAE/B,OAAO;MACN,GAAGA,MAAM;MACT,CAACD,IAAI,GAAG;IACT,CAAC;EACF,CAAC,EAAE,CAACA,IAAI,EAAEC,MAAM,CAAC,CAAC;AACnB,CAAC","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/scroll-coordination/update-scroll-gesture-state.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createScrollGestureAxisState","offset","contentSize","layoutSize","isTouched","createScrollGestureState","vertical","horizontal","createScrollMetadataState","updateScrollGestureAxisState","state","axis","patch","nextState","axisState","undefined","updateScrollMetadataAxisState","clearScrollMetadataAxisState"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/scroll-coordination/update-scroll-gesture-state.ts"],"mappings":";;AAOA,SAASA,4BAA4BA,CAAA,EAA2B;EAC/D,SAAS;;EACT,OAAO;IAAEC,MAAM,EAAE,CAAC;IAAEC,WAAW,EAAE,CAAC;IAAEC,UAAU,EAAE,CAAC;IAAEC,SAAS,EAAE;EAAM,CAAC;AACtE;AAEA,MAAMC,wBAAwB,GAAGA,CAAA,KAA0B;EAC1D,SAAS;;EACT,OAAO;IACNC,QAAQ,EAAEN,4BAA4B,CAAC,CAAC;IACxCO,UAAU,EAAEP,4BAA4B,CAAC;EAC1C,CAAC;AACF,CAAC;AAED,MAAMQ,yBAAyB,GAAGA,CAAA,KAA2B;EAC5D,SAAS;;EACT,OAAO;IACNF,QAAQ,EAAE,IAAI;IACdC,UAAU,EAAE;EACb,CAAC;AACF,CAAC;AAED,OAAO,MAAME,4BAA4B,GAAGA,CAC3CC,KAAgC,EAChCC,IAAuB,EACvBC,KAAgE,KACxC;EACxB,SAAS;;EAET,MAAMC,SAAS,GAAGH,KAAK,IAAIL,wBAAwB,CAAC,CAAC;EAErD,MAAMS,SAAS,GAAGD,SAAS,CAACF,IAAI,CAAC;EAEjC,IAAIC,KAAK,CAACX,MAAM,KAAKc,SAAS,EAAE;IAC/BD,SAAS,CAACb,MAAM,GAAGW,KAAK,CAACX,MAAM;EAChC;EAEA,IAAIW,KAAK,CAACV,WAAW,KAAKa,SAAS,EAAE;IACpCD,SAAS,CAACZ,WAAW,GAAGU,KAAK,CAACV,WAAW;EAC1C;EAEA,IAAIU,KAAK,CAACT,UAAU,KAAKY,SAAS,EAAE;IACnCD,SAAS,CAACX,UAAU,GAAGS,KAAK,CAACT,UAAU;EACxC;EAEA,IAAIS,KAAK,CAACR,SAAS,KAAKW,SAAS,EAAE;IAClCD,SAAS,CAACV,SAAS,GAAGQ,KAAK,CAACR,SAAS;EACtC;EAEA,OAAOS,SAAS;AACjB,CAAC;AAED,OAAO,MAAMG,6BAA6B,GAAGA,CAC5CN,KAAiC,EACjCC,IAAuB,EACvBC,KAAgE,KACvC;EACzB,SAAS;;EAET,MAAMC,SAAS,GAAGH,KAAK,IAAIF,yBAAyB,CAAC,CAAC;EACtD,MAAMM,SAAS,GAAGD,SAAS,CAACF,IAAI,CAAC,IAAIX,4BAA4B,CAAC,CAAC;EACnEa,SAAS,CAACF,IAAI,CAAC,GAAGG,SAAS;EAE3B,IAAIF,KAAK,CAACX,MAAM,KAAKc,SAAS,EAAE;IAC/BD,SAAS,CAACb,MAAM,GAAGW,KAAK,CAACX,MAAM;EAChC;EAEA,IAAIW,KAAK,CAACV,WAAW,KAAKa,SAAS,EAAE;IACpCD,SAAS,CAACZ,WAAW,GAAGU,KAAK,CAACV,WAAW;EAC1C;EAEA,IAAIU,KAAK,CAACT,UAAU,KAAKY,SAAS,EAAE;IACnCD,SAAS,CAACX,UAAU,GAAGS,KAAK,CAACT,UAAU;EACxC;EAEA,IAAIS,KAAK,CAACR,SAAS,KAAKW,SAAS,EAAE;IAClCD,SAAS,CAACV,SAAS,GAAGQ,KAAK,CAACR,SAAS;EACtC;EAEA,OAAOS,SAAS;AACjB,CAAC;AAED,OAAO,MAAMI,4BAA4B,GAAGA,CAC3CP,KAAiC,EACjCC,IAAuB,KACS;EAChC,SAAS;;EACT,IAAI,CAACD,KAAK,EAAE,OAAO,IAAI;EAEvBA,KAAK,CAACC,IAAI,CAAC,GAAG,IAAI;EAElB,OAAOD,KAAK,CAACJ,QAAQ,IAAII,KAAK,CAACH,UAAU,GAAGG,KAAK,GAAG,IAAI;AACzD,CAAC","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/scroll-coordination/use-scroll-gesture-coordination.js

@@ -0,0 +1,204 @@
+"use strict";
+
+import { useLayoutEffect, useMemo, useState } from "react";
+import { Gesture } from "react-native-gesture-handler";
+import { useAnimatedScrollHandler, useDerivedValue } from "react-native-reanimated";
+import { useSharedValueState } from "../../../../../hooks/reanimated/use-shared-value-state";
+import useStableCallback from "../../../../../hooks/use-stable-callback";
+import { ScrollStore } from "../../../../../stores/scroll.store";
+import { useMotionStore, useOptionalMotionStore } from "../..";
+import { useGestureScrollCoordination } from "../ownership/use-gesture-scroll-coordination";
+import { useOptionalScrollMetadataOwnerStore, useScrollMetadataOwnerProviderValue } from "./scroll-metadata-owner";
+import { clearScrollMetadataAxisState, updateScrollGestureAxisState, updateScrollMetadataAxisState } from "./update-scroll-gesture-state";
+const modifyScrollGestureAxisState = (scrollState, axis, patch) => {
+  "worklet";
+
+  scrollState.modify(state => {
+    "worklet";
+
+    return updateScrollGestureAxisState(state, axis, patch);
+  });
+};
+const modifyScrollMetadataAxisState = (scrollState, axis, patch) => {
+  "worklet";
+
+  scrollState.modify(state => {
+    "worklet";
+
+    return updateScrollMetadataAxisState(state, axis, patch);
+  });
+};
+const clearScrollMetadataAxis = (scrollState, axis) => {
+  "worklet";
+
+  scrollState.modify(state => {
+    "worklet";
+
+    return clearScrollMetadataAxisState(state, axis);
+  });
+};
+
+/**
+ * Returns scroll handlers and a native gesture for ScrollView coordination.
+ *
+ * Finds ALL gesture owners for the scroll axis (both directions) and coordinates
+ * with each of them. This ensures that:
+ * - A screen claiming `vertical-inverted` can handle swipe-up at bottom boundary
+ * - An ancestor claiming `vertical` can handle swipe-down at top boundary
+ * - Both work correctly with the same ScrollView
+ */
+export const useScrollGestureCoordination = props => {
+  const context = useOptionalMotionStore(store => store?.gestures ?? null);
+  const scrollDirection = props.direction ?? "vertical";
+  const routeKey = context?.routeKey ?? null;
+  const {
+    scrollStates,
+    panGestures,
+    pinchGestures,
+    ownerRouteKeys
+  } = useGestureScrollCoordination(routeKey, scrollDirection);
+  const metadataOwnerContext = useOptionalScrollMetadataOwnerStore();
+  const metadataOwnerProviderValue = useScrollMetadataOwnerProviderValue(scrollDirection);
+  const isFirstMetadataWriterInTree = !metadataOwnerContext?.[scrollDirection];
+  const [metadataWriterId] = useState(() => ScrollStore.createMetadataWriterId());
+  const [writesMetadata, setWritesMetadata] = useState(false);
+  const metadataState = useMemo(() => routeKey ? ScrollStore.getValue(routeKey, "metadata") : null, [routeKey]);
+  useLayoutEffect(() => {
+    if (!routeKey || !isFirstMetadataWriterInTree) {
+      setWritesMetadata(false);
+      return;
+    }
+    const claimed = ScrollStore.claimMetadataWriter(routeKey, scrollDirection, metadataWriterId);
+    setWritesMetadata(claimed);
+    return () => {
+      const released = ScrollStore.releaseMetadataWriter(routeKey, scrollDirection, metadataWriterId);
+      if (!released || !metadataState) return;
+      if (!ScrollStore.hasMetadataWriters(routeKey)) {
+        metadataState.set(null);
+        return;
+      }
+      clearScrollMetadataAxis(metadataState, scrollDirection);
+    };
+  }, [routeKey, scrollDirection, isFirstMetadataWriterInTree, metadataState, metadataWriterId]);
+  const ownerMotions = useMotionStore(ownerRouteKeys);
+  const ownerClosingValues = useMemo(() => ownerMotions.flatMap(motion => motion ? [motion.state.closing] : []), [ownerMotions]);
+  const scrollEventsEnabled = useSharedValueState(useDerivedValue(() => {
+    "worklet";
+
+    for (let i = 0; i < ownerClosingValues.length; i++) {
+      if (ownerClosingValues[i].get()) {
+        return false;
+      }
+    }
+    return true;
+  }));
+  const nativeGesture = useMemo(() => {
+    // Ownership registrations disappear while a screen's Activity is paused.
+    // Keep its detector mounted through that gap: removing the wrapper remounts
+    // scroll children and loses state, including captured boundary measurements.
+    if (!routeKey) return null;
+    const setIsTouched = () => {
+      "worklet";
+
+      for (const scrollState of scrollStates) {
+        modifyScrollGestureAxisState(scrollState, scrollDirection, {
+          isTouched: true
+        });
+      }
+      if (writesMetadata && metadataState) {
+        modifyScrollMetadataAxisState(metadataState, scrollDirection, {
+          isTouched: true
+        });
+      }
+    };
+    const clearIsTouched = () => {
+      "worklet";
+
+      for (const scrollState of scrollStates) {
+        modifyScrollGestureAxisState(scrollState, scrollDirection, {
+          isTouched: false
+        });
+      }
+      if (writesMetadata && metadataState) {
+        modifyScrollMetadataAxisState(metadataState, scrollDirection, {
+          isTouched: false
+        });
+      }
+    };
+    let gesture = Gesture.Native().onTouchesDown(setIsTouched).onTouchesUp(clearIsTouched).onTouchesCancelled(clearIsTouched);
+    for (const panGesture of panGestures) {
+      gesture = gesture.requireExternalGestureToFail({
+        current: panGesture
+      });
+    }
+    for (const pinchGesture of pinchGestures) {
+      // A pinch must remain possible after the first finger lands. Making
+      // native scrolling wait for it to fail therefore stalls ordinary
+      // one-finger scrolling until touch-up. Let both recognizers run:
+      // the ScrollView can begin immediately, while a second finger can
+      // still promote the screen gesture to a pinch.
+      gesture = gesture.simultaneousWithExternalGesture({
+        current: pinchGesture
+      });
+    }
+    return gesture;
+  }, [routeKey, panGestures, pinchGestures, scrollStates, scrollDirection, writesMetadata, metadataState]);
+  const scrollHandler = useAnimatedScrollHandler({
+    onScroll: event => {
+      const offset = scrollDirection === "horizontal" ? event.contentOffset.x : event.contentOffset.y;
+      for (const scrollState of scrollStates) {
+        modifyScrollGestureAxisState(scrollState, scrollDirection, {
+          offset,
+          isTouched: scrollState.get()?.[scrollDirection].isTouched ?? true
+        });
+      }
+      if (writesMetadata && metadataState) {
+        modifyScrollMetadataAxisState(metadataState, scrollDirection, {
+          offset,
+          isTouched: metadataState.get()?.[scrollDirection]?.isTouched ?? true
+        });
+      }
+    }
+  });
+  const onContentSizeChange = useStableCallback((width, height) => {
+    props.onContentSizeChange?.(width, height);
+    const contentSize = scrollDirection === "horizontal" ? width : height;
+    for (const scrollState of scrollStates) {
+      modifyScrollGestureAxisState(scrollState, scrollDirection, {
+        contentSize
+      });
+    }
+    if (writesMetadata && metadataState) {
+      modifyScrollMetadataAxisState(metadataState, scrollDirection, {
+        contentSize
+      });
+    }
+  });
+  const onLayout = useStableCallback(event => {
+    props.onLayout?.(event);
+    const {
+      width,
+      height
+    } = event.nativeEvent.layout;
+    const layoutSize = scrollDirection === "horizontal" ? width : height;
+    for (const scrollState of scrollStates) {
+      modifyScrollGestureAxisState(scrollState, scrollDirection, {
+        layoutSize
+      });
+    }
+    if (writesMetadata && metadataState) {
+      modifyScrollMetadataAxisState(metadataState, scrollDirection, {
+        layoutSize
+      });
+    }
+  });
+  return {
+    scrollHandler,
+    scrollEventsEnabled,
+    onContentSizeChange,
+    onLayout,
+    nativeGesture,
+    metadataOwnerProviderValue
+  };
+};
+//# sourceMappingURL=use-scroll-gesture-coordination.js.map

package/lib/module/providers/screen/motion/gestures/scroll-coordination/use-scroll-gesture-coordination.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useLayoutEffect","useMemo","useState","Gesture","useAnimatedScrollHandler","useDerivedValue","useSharedValueState","useStableCallback","ScrollStore","useMotionStore","useOptionalMotionStore","useGestureScrollCoordination","useOptionalScrollMetadataOwnerStore","useScrollMetadataOwnerProviderValue","clearScrollMetadataAxisState","updateScrollGestureAxisState","updateScrollMetadataAxisState","modifyScrollGestureAxisState","scrollState","axis","patch","modify","state","modifyScrollMetadataAxisState","clearScrollMetadataAxis","useScrollGestureCoordination","props","context","store","gestures","scrollDirection","direction","routeKey","scrollStates","panGestures","pinchGestures","ownerRouteKeys","metadataOwnerContext","metadataOwnerProviderValue","isFirstMetadataWriterInTree","metadataWriterId","createMetadataWriterId","writesMetadata","setWritesMetadata","metadataState","getValue","claimed","claimMetadataWriter","released","releaseMetadataWriter","hasMetadataWriters","set","ownerMotions","ownerClosingValues","flatMap","motion","closing","scrollEventsEnabled","i","length","get","nativeGesture","setIsTouched","isTouched","clearIsTouched","gesture","Native","onTouchesDown","onTouchesUp","onTouchesCancelled","panGesture","requireExternalGestureToFail","current","pinchGesture","simultaneousWithExternalGesture","scrollHandler","onScroll","event","offset","contentOffset","x","y","onContentSizeChange","width","height","contentSize","onLayout","nativeEvent","layout","layoutSize"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/scroll-coordination/use-scroll-gesture-coordination.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/shared/directions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isPinchGestureDirection","direction","isPanGestureDirection","isResolvedPanGestureDirection","gesture","getGestureDirectionEntryGesture","entry","getGestureDirectionEntries","gestureDirection","Array","isArray","getPanGestureDirections","panDirections","push","getPinchGestureDirections","pinchDirections","getOppositePanDirection","getPanDirectionAxis","setSnapPanAxisConfig","config","axis","collapse","expand","inverted","progressSign","getPanSnapAxisDirections","horizontal","vertical","getSnapPinchDirectionConfig","pinchDirection","getPanActivationDirections","hasSnapPoints","snapAxisDirections","verticalInverted","horizontalInverted","isBidirectional","includes","getPanSnapAxisConfigForDirection"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/shared/directions.ts"],"mappings":";;AAqBA,MAAMA,uBAAuB,GAC5BC,SAA2B,IACa;EACxC,SAAS;;EACT,OAAOA,SAAS,KAAK,UAAU,IAAIA,SAAS,KAAK,WAAW;AAC7D,CAAC;AAED,MAAMC,qBAAqB,GAC1BD,SAA2B,IACW;EACtC,SAAS;;EACT,OAAO,CAACD,uBAAuB,CAACC,SAAS,CAAC;AAC3C,CAAC;AAED,OAAO,MAAME,6BAA6B,GACzCC,OAA6B,IACe;EAC5C,SAAS;;EACT,OACCA,OAAO,KAAK,YAAY,IACxBA,OAAO,KAAK,qBAAqB,IACjCA,OAAO,KAAK,UAAU,IACtBA,OAAO,KAAK,mBAAmB;AAEjC,CAAC;AAED,OAAO,MAAMC,+BAA+B,GAC3CC,KAA4B,IACN;EACtB,SAAS;;EACT,OAAO,OAAOA,KAAK,KAAK,QAAQ,GAAGA,KAAK,GAAGA,KAAK,CAACF,OAAO;AACzD,CAAC;AAED,OAAO,MAAMG,0BAA0B,GACtCC,gBAAwC,IACX;EAC7B,SAAS;;EACT,OAAOC,KAAK,CAACC,OAAO,CAACF,gBAAgB,CAAC,GACnCA,gBAAgB,GAChB,CAACA,gBAAgB,CAAC;AACtB,CAAC;AAED,OAAO,MAAMG,uBAAuB,GACnCH,gBAAwC,IACb;EAC3B,SAAS;;EACT,MAAMI,aAAoC,GAAG,EAAE;EAE/C,KAAK,MAAMN,KAAK,IAAIC,0BAA0B,CAACC,gBAAgB,CAAC,EAAE;IACjE,MAAMP,SAAS,GAAGI,+BAA+B,CAACC,KAAK,CAAC;IACxD,IAAIJ,qBAAqB,CAACD,SAAS,CAAC,EAAE;MACrCW,aAAa,CAACC,IAAI,CAACZ,SAAS,CAAC;IAC9B;EACD;EAEA,OAAOW,aAAa;AACrB,CAAC;AAED,OAAO,MAAME,yBAAyB,GACrCN,gBAAwC,IACX;EAC7B,SAAS;;EACT,MAAMO,eAAwC,GAAG,EAAE;EAEnD,KAAK,MAAMT,KAAK,IAAIC,0BAA0B,CAACC,gBAAgB,CAAC,EAAE;IACjE,MAAMP,SAAS,GAAGI,+BAA+B,CAACC,KAAK,CAAC;IACxD,IAAIN,uBAAuB,CAACC,SAAS,CAAC,EAAE;MACvCc,eAAe,CAACF,IAAI,CAACZ,SAAS,CAAC;IAChC;EACD;EAEA,OAAOc,eAAe;AACvB,CAAC;AAED,MAAMC,uBAAuB,GAC5Bf,SAAsC,IACL;EACjC,SAAS;;EACT,QAAQA,SAAS;IAChB,KAAK,YAAY;MAChB,OAAO,qBAAqB;IAC7B,KAAK,qBAAqB;MACzB,OAAO,YAAY;IACpB,KAAK,UAAU;MACd,OAAO,mBAAmB;IAC3B,KAAK,mBAAmB;MACvB,OAAO,UAAU;EACnB;AACD,CAAC;AAED,MAAMgB,mBAAmB,GACxBhB,SAAsC,IACrB;EACjB,SAAS;;EACT,OAAOA,SAAS,KAAK,YAAY,IAAIA,SAAS,KAAK,qBAAqB,GACrE,YAAY,GACZ,UAAU;AACd,CAAC;AAED,MAAMiB,oBAAoB,GAAGA,CAC5BC,MAA8B,EAC9BlB,SAAsC,KAClC;EACJ,SAAS;;EACT,MAAMmB,IAAI,GAAGH,mBAAmB,CAAChB,SAAS,CAAC;EAE3C,IAAIkB,MAAM,CAACC,IAAI,CAAC,EAAE;EAElBD,MAAM,CAACC,IAAI,CAAC,GAAG;IACdC,QAAQ,EAAEpB,SAAS;IACnBqB,MAAM,EAAEN,uBAAuB,CAACf,SAAS,CAAC;IAC1CsB,QAAQ,EACPtB,SAAS,KAAK,qBAAqB,IAAIA,SAAS,KAAK,mBAAmB;IACzEuB,YAAY,EACXvB,SAAS,KAAK,qBAAqB,IAAIA,SAAS,KAAK,mBAAmB,GACrE,CAAC,GACD,CAAC;EACN,CAAC;AACF,CAAC;AAED,OAAO,MAAMwB,wBAAwB,GACpCjB,gBAAwC,IACZ;EAC5B,SAAS;;EACT,MAAMW,MAA8B,GAAG;IACtCO,UAAU,EAAE,IAAI;IAChBC,QAAQ,EAAE;EACX,CAAC;EAED,KAAK,MAAM1B,SAAS,IAAIU,uBAAuB,CAACH,gBAAgB,CAAC,EAAE;IAClE,IAAIP,SAAS,KAAK,eAAe,EAAE;MAClCiB,oBAAoB,CAACC,MAAM,EAAE,YAAY,CAAC;MAC1CD,oBAAoB,CAACC,MAAM,EAAE,UAAU,CAAC;MACxC;IACD;IAEAD,oBAAoB,CAACC,MAAM,EAAElB,SAAS,CAAC;EACxC;EAEA,OAAOkB,MAAM;AACd,CAAC;AAED,OAAO,MAAMS,2BAA2B,GACvCpB,gBAAwC,IACV;EAC9B,SAAS;;EACT,MAAMqB,cAAc,GAAGf,yBAAyB,CAACN,gBAAgB,CAAC,CAAC,CAAC,CAAC;EAErE,IAAI,CAACqB,cAAc,EAAE,OAAO,IAAI;EAEhC,OAAO;IACNR,QAAQ,EAAEQ,cAAc;IACxBP,MAAM,EAAEO,cAAc,KAAK,UAAU,GAAG,WAAW,GAAG;EACvD,CAAC;AACF,CAAC;AAED,OAAO,MAAMC,0BAA0B,GAAGA,CAAC;EAC1CtB,gBAAgB;EAChBuB;AACgC,CAAC,KAAwB;EACzD,SAAS;;EACT,MAAMnB,aAAa,GAAGD,uBAAuB,CAACH,gBAAgB,CAAC;EAE/D,IAAIuB,aAAa,EAAE;IAClB,MAAMC,kBAAkB,GAAGP,wBAAwB,CAACjB,gBAAgB,CAAC;IAErE,OAAO;MACNmB,QAAQ,EAAE,CAAC,CAACK,kBAAkB,CAACL,QAAQ;MACvCM,gBAAgB,EAAE,CAAC,CAACD,kBAAkB,CAACL,QAAQ;MAC/CD,UAAU,EAAE,CAAC,CAACM,kBAAkB,CAACN,UAAU;MAC3CQ,kBAAkB,EAAE,CAAC,CAACF,kBAAkB,CAACN;IAC1C,CAAC;EACF;EAEA,MAAMS,eAAe,GAAGvB,aAAa,CAACwB,QAAQ,CAAC,eAAe,CAAC;EAE/D,OAAO;IACNT,QAAQ,EAAEf,aAAa,CAACwB,QAAQ,CAAC,UAAU,CAAC,IAAID,eAAe;IAC/DF,gBAAgB,EACfrB,aAAa,CAACwB,QAAQ,CAAC,mBAAmB,CAAC,IAAID,eAAe;IAC/DT,UAAU,EAAEd,aAAa,CAACwB,QAAQ,CAAC,YAAY,CAAC,IAAID,eAAe;IACnED,kBAAkB,EACjBtB,aAAa,CAACwB,QAAQ,CAAC,qBAAqB,CAAC,IAAID;EACnD,CAAC;AACF,CAAC;AAED,OAAO,MAAME,gCAAgC,GAAGA,CAC/CL,kBAA0C,EAC1C/B,SAAoB,KACyC;EAC7D,SAAS;;EACT,MAAMmB,IAAI,GAAGH,mBAAmB,CAAChB,SAAS,CAAC;EAC3C,MAAMkB,MAAM,GAAGa,kBAAkB,CAACZ,IAAI,CAAC;EAEvC,IAAI,CAACD,MAAM,EAAE,OAAO,IAAI;EAExB,OAAO;IAAEC,IAAI;IAAED;EAAO,CAAC;AACxB,CAAC","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/shared/physics.js

@@ -0,0 +1,213 @@
+"use strict";
+
+import { clamp } from "react-native-reanimated";
+import { EPSILON } from "../../../../../constants";
+const FULL_GESTURE_VELOCITY_PROGRESS_PER_SECOND = 4;
+
+/**
+ * Converts a pan velocity from pixels/second into progress/second.
+ */
+export const toProgressVelocity = (velocityPixelsPerSecond, screenSize) => {
+  "worklet";
+
+  return velocityPixelsPerSecond / Math.max(1, screenSize);
+};
+
+/**
+ * Converts normalized gesture velocity into a 0-1 scalar for interpolators.
+ *
+ * `1` means the velocity reached or exceeded the library's full-velocity
+ * threshold, not a physical maximum for the device.
+ */
+export const resolveGestureVelocityMagnitude = velocity => {
+  "worklet";
+
+  return Math.min(1, Math.abs(velocity) / FULL_GESTURE_VELOCITY_PROGRESS_PER_SECOND);
+};
+export const resolveGestureVelocity = (velocityNormX, velocityNormY) => {
+  "worklet";
+
+  return resolveGestureVelocityMagnitude(Math.max(Math.abs(velocityNormX), Math.abs(velocityNormY)));
+};
+
+/**
+ * Converts pan release velocity into a spring handoff in progress units/second.
+ */
+export const getPanReleaseHandoffVelocity = (velocityPixelsPerSecond, screenSize, gestureReleaseVelocityScale = 1) => {
+  "worklet";
+
+  return toProgressVelocity(velocityPixelsPerSecond, screenSize) * Math.max(0, gestureReleaseVelocityScale);
+};
+
+/**
+ * Converts pinch scale velocity into a spring handoff in progress units/second.
+ */
+export const getPinchReleaseHandoffVelocity = (velocityScalePerSecond, gestureReleaseVelocityScale = 1) => {
+  "worklet";
+
+  return velocityScalePerSecond * Math.max(0, gestureReleaseVelocityScale);
+};
+const getPanAxisCandidate = (isEnabled, translationTowardDismiss, velocityTowardDismiss, screenSize) => {
+  "worklet";
+
+  if (!isEnabled || translationTowardDismiss <= 0) {
+    return null;
+  }
+  return {
+    progressContribution: translationTowardDismiss / Math.max(1, screenSize),
+    velocityContribution: getPanReleaseHandoffVelocity(velocityTowardDismiss, screenSize)
+  };
+};
+const pushPanAxisCandidate = (candidates, candidate) => {
+  "worklet";
+
+  if (candidate) {
+    candidates.push(candidate);
+  }
+};
+const collectPanAxisCandidates = ({
+  event,
+  dimensions,
+  directions
+}) => {
+  "worklet";
+
+  const candidates = [];
+  pushPanAxisCandidate(candidates, getPanAxisCandidate(directions.horizontal, event.translationX, event.velocityX, dimensions.width));
+  pushPanAxisCandidate(candidates, getPanAxisCandidate(directions.horizontalInverted, -event.translationX, -event.velocityX, dimensions.width));
+  pushPanAxisCandidate(candidates, getPanAxisCandidate(directions.vertical, event.translationY, event.velocityY, dimensions.height));
+  pushPanAxisCandidate(candidates, getPanAxisCandidate(directions.verticalInverted, -event.translationY, -event.velocityY, dimensions.height));
+  return candidates;
+};
+const getDominantPanCandidateVelocity = candidates => {
+  "worklet";
+
+  if (candidates.length === 0) {
+    return null;
+  }
+  let dominant = candidates[0];
+  for (let i = 1; i < candidates.length; i++) {
+    const candidate = candidates[i];
+    if (candidate.progressContribution > dominant.progressContribution) {
+      dominant = candidate;
+    }
+  }
+  return Math.abs(dominant.velocityContribution);
+};
+const getFallbackPanReleaseVelocityMagnitude = ({
+  event,
+  dimensions
+}) => {
+  "worklet";
+
+  const normalizedVelocityX = getPanReleaseHandoffVelocity(event.velocityX, dimensions.width);
+  const normalizedVelocityY = getPanReleaseHandoffVelocity(event.velocityY, dimensions.height);
+  return Math.max(Math.abs(normalizedVelocityX), Math.abs(normalizedVelocityY));
+};
+
+/**
+ * Normalizes translation to -1...1 range (for gesture tracking).
+ * Used to convert pixel translation to normalized gesture values.
+ */
+export const normalizeGestureTranslation = (translation, dimension) => {
+  "worklet";
+
+  return clamp(translation / Math.max(1, dimension), -1, 1);
+};
+
+/**
+ * Picks the dominant active pan axis and returns a release handoff velocity
+ * in progress units/second oriented toward the animation target.
+ */
+export const getPanReleaseProgressVelocity = ({
+  animations,
+  shouldDismiss,
+  event,
+  dimensions,
+  directions
+}) => {
+  "worklet";
+
+  const currentProgress = animations.transitionProgress.get();
+  const targetProgress = shouldDismiss ? 0 : 1;
+  const progressDelta = targetProgress - currentProgress;
+  const progressDirection = progressDelta === 0 ? 0 : Math.sign(progressDelta);
+  const dominantVelocity = getDominantPanCandidateVelocity(collectPanAxisCandidates({
+    event,
+    dimensions,
+    directions
+  }));
+  const progressVelocityMagnitude = dominantVelocity ?? getFallbackPanReleaseVelocityMagnitude({
+    event,
+    dimensions
+  });
+  return progressDirection * progressVelocityMagnitude;
+};
+
+/**
+ * Determines if a gesture should trigger dismissal based on combined
+ * translation and velocity in normalized screen units (0-1 range).
+ *
+ * Formula: |translation/screen + velocity/screen * velocityWeight| > 0.5
+ */
+export const shouldDismissFromProjection = (translationPixels, velocityPixelsPerSecond, screenSize, velocityWeight) => {
+  "worklet";
+
+  const normalizedTranslation = translationPixels / Math.max(1, screenSize);
+
+  // If translation is essentially zero, velocity alone shouldn't trigger dismissal.
+  // User must have meaningfully moved in the dismiss direction.
+  if (Math.abs(normalizedTranslation) < EPSILON) {
+    return false;
+  }
+  const normalizedVelocity = toProgressVelocity(velocityPixelsPerSecond, screenSize);
+  const projectedNormalizedPosition = normalizedTranslation + normalizedVelocity * velocityWeight;
+
+  // The dismiss direction is determined by the sign of the translation.
+  // Multiplying by this sign normalizes the projection so "toward dismiss" is always positive.
+  // This prevents dismissal when the user drags back (opposing velocity flips projection negative).
+  const dismissSign = Math.sign(translationPixels);
+  const projectedInDismissDirection = projectedNormalizedPosition * dismissSign;
+  const exceedsThreshold = projectedInDismissDirection > 0.5;
+  return exceedsThreshold;
+};
+
+/**
+ * Scales live gesture movement before it is applied to transition progress.
+ * Lower values reduce sensitivity, higher values increase it.
+ */
+export const applyGestureSensitivity = (progressDelta, gestureSensitivity = 1) => {
+  "worklet";
+
+  return progressDelta * Math.max(0, gestureSensitivity);
+};
+
+/**
+ * Normalizes pinch scale so idle is 0, pinch-in is negative, and pinch-out is positive.
+ * This intentionally returns the raw delta so sensitivity can be applied before
+ * the live gesture is clamped into progress space.
+ *
+ * Examples:
+ * - 0.5 scale => -0.5
+ * - 1.0 scale => 0
+ * - 1.5 scale => 0.5
+ * - 2.0 scale => 1
+ * - 3.0 scale => 2
+ */
+export const normalizePinchScale = scale => {
+  "worklet";
+
+  return scale - 1;
+};
+export const shouldDismissFromPinch = (normalizedScale, pinchInEnabled, pinchOutEnabled) => {
+  "worklet";
+
+  if (normalizedScale < 0 && !pinchInEnabled) {
+    return false;
+  }
+  if (normalizedScale > 0 && !pinchOutEnabled) {
+    return false;
+  }
+  return Math.abs(normalizedScale) > 0.5;
+};
+//# sourceMappingURL=physics.js.map