react-native-screen-transitions 4.0.0 → 4.1.0-beta.0

package/lib/module/providers/screen/motion/gestures/ownership/compute-claimed-directions.js

@@ -0,0 +1,71 @@
+"use strict";
+
+import { DEFAULT_GESTURE_DIRECTION } from "../../../../../constants";
+import { NO_CLAIMS } from "../../../../../types/ownership.types";
+import { getPanGestureDirections } from "../shared/directions";
+const createClaimSet = () => ({
+  vertical: false,
+  "vertical-inverted": false,
+  horizontal: false,
+  "horizontal-inverted": false
+});
+const normalizePanGestureDirections = gestureDirection => {
+  const direction = gestureDirection ?? DEFAULT_GESTURE_DIRECTION;
+  return getPanGestureDirections(direction);
+};
+const claimPanDirection = (claims, direction) => {
+  if (direction === "bidirectional") {
+    claims.vertical = true;
+    claims["vertical-inverted"] = true;
+    claims.horizontal = true;
+    claims["horizontal-inverted"] = true;
+    return;
+  }
+  claims[direction] = true;
+};
+const expandSnapPointAxisClaims = claims => {
+  const hasVerticalAxis = claims.vertical || claims["vertical-inverted"];
+  const hasHorizontalAxis = claims.horizontal || claims["horizontal-inverted"];
+  if (hasVerticalAxis) {
+    claims.vertical = true;
+    claims["vertical-inverted"] = true;
+  }
+  if (hasHorizontalAxis) {
+    claims.horizontal = true;
+    claims["horizontal-inverted"] = true;
+  }
+};
+
+/**
+ * Computes which directions a screen claims ownership of.
+ *
+ * A screen claims a direction when:
+ * 1. direction claiming is enabled AND
+ * 2. gestureDirection includes that direction
+ *
+ * For snap points, both directions on each configured pan axis are claimed.
+ * The first direction on an axis collapses; its inverse expands.
+ *
+ * @param canClaimDirections - Whether this screen can own gesture directions
+ * @param gestureDirection - The gesture direction(s) configured for this screen
+ * @param hasSnapPoints - Whether this screen has snap points configured
+ * @returns The claimed directions for this screen
+ */
+export function computeClaimedDirections(canClaimDirections, gestureDirection, hasSnapPoints) {
+  if (!canClaimDirections) {
+    return NO_CLAIMS;
+  }
+  const directions = normalizePanGestureDirections(gestureDirection);
+  if (directions.length === 0) {
+    return NO_CLAIMS;
+  }
+  const claims = createClaimSet();
+  for (const dir of directions) {
+    claimPanDirection(claims, dir);
+  }
+  if (hasSnapPoints) {
+    expandSnapPointAxisClaims(claims);
+  }
+  return claims;
+}
+//# sourceMappingURL=compute-claimed-directions.js.map

package/lib/module/providers/screen/motion/gestures/ownership/compute-claimed-directions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DEFAULT_GESTURE_DIRECTION","NO_CLAIMS","getPanGestureDirections","createClaimSet","vertical","horizontal","normalizePanGestureDirections","gestureDirection","direction","claimPanDirection","claims","expandSnapPointAxisClaims","hasVerticalAxis","hasHorizontalAxis","computeClaimedDirections","canClaimDirections","hasSnapPoints","directions","length","dir"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/ownership/compute-claimed-directions.ts"],"mappings":";;AAAA,SAASA,yBAAyB,QAAQ,0BAA0B;AAKpE,SAGCC,SAAS,QACH,sCAAsC;AAC7C,SAASC,uBAAuB,QAAQ,sBAAsB;AAE9D,MAAMC,cAAc,GAAGA,CAAA,MAA0B;EAChDC,QAAQ,EAAE,KAAK;EACf,mBAAmB,EAAE,KAAK;EAC1BC,UAAU,EAAE,KAAK;EACjB,qBAAqB,EAAE;AACxB,CAAC,CAAC;AAEF,MAAMC,6BAA6B,GAClCC,gBAAoD,IAChD;EACJ,MAAMC,SAAS,GAAGD,gBAAgB,IAAIP,yBAAyB;EAC/D,OAAOE,uBAAuB,CAACM,SAAS,CAAC;AAC1C,CAAC;AAED,MAAMC,iBAAiB,GAAGA,CACzBC,MAAyB,EACzBF,SAA8B,KAC1B;EACJ,IAAIA,SAAS,KAAK,eAAe,EAAE;IAClCE,MAAM,CAACN,QAAQ,GAAG,IAAI;IACtBM,MAAM,CAAC,mBAAmB,CAAC,GAAG,IAAI;IAClCA,MAAM,CAACL,UAAU,GAAG,IAAI;IACxBK,MAAM,CAAC,qBAAqB,CAAC,GAAG,IAAI;IACpC;EACD;EAEAA,MAAM,CAACF,SAAS,CAAc,GAAG,IAAI;AACtC,CAAC;AAED,MAAMG,yBAAyB,GAAID,MAAyB,IAAK;EAChE,MAAME,eAAe,GAAGF,MAAM,CAACN,QAAQ,IAAIM,MAAM,CAAC,mBAAmB,CAAC;EACtE,MAAMG,iBAAiB,GAAGH,MAAM,CAACL,UAAU,IAAIK,MAAM,CAAC,qBAAqB,CAAC;EAE5E,IAAIE,eAAe,EAAE;IACpBF,MAAM,CAACN,QAAQ,GAAG,IAAI;IACtBM,MAAM,CAAC,mBAAmB,CAAC,GAAG,IAAI;EACnC;EAEA,IAAIG,iBAAiB,EAAE;IACtBH,MAAM,CAACL,UAAU,GAAG,IAAI;IACxBK,MAAM,CAAC,qBAAqB,CAAC,GAAG,IAAI;EACrC;AACD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASI,wBAAwBA,CACvCC,kBAA2B,EAC3BR,gBAAoD,EACpDS,aAAsB,EACF;EACpB,IAAI,CAACD,kBAAkB,EAAE;IACxB,OAAOd,SAAS;EACjB;EAEA,MAAMgB,UAAU,GAAGX,6BAA6B,CAACC,gBAAgB,CAAC;EAElE,IAAIU,UAAU,CAACC,MAAM,KAAK,CAAC,EAAE;IAC5B,OAAOjB,SAAS;EACjB;EAEA,MAAMS,MAAM,GAAGP,cAAc,CAAC,CAAC;EAE/B,KAAK,MAAMgB,GAAG,IAAIF,UAAU,EAAE;IAC7BR,iBAAiB,CAACC,MAAM,EAAES,GAAG,CAAC;EAC/B;EAEA,IAAIH,aAAa,EAAE;IAClBL,yBAAyB,CAACD,MAAM,CAAC;EAClC;EAEA,OAAOA,MAAM;AACd","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/ownership/gesture-ownership-coordinator.js

@@ -0,0 +1,144 @@
+"use strict";
+
+import { DIRECTIONS } from "../../../../../types/ownership.types";
+import { screenTopology } from "../../../builder/topology";
+const EMPTY_SCROLL_COORDINATION = {
+  panGestures: [],
+  pinchGestures: [],
+  scrollStates: [],
+  ownerRouteKeys: []
+};
+const createEmptyOwners = () => ({
+  vertical: null,
+  "vertical-inverted": null,
+  horizontal: null,
+  "horizontal-inverted": null
+});
+const areOwnersEqual = (left, right) => DIRECTIONS.every(direction => left[direction] === right[direction]);
+const areArraysEqual = (left, right) => left.length === right.length && left.every((value, index) => value === right[index]);
+const areScrollCoordinationsEqual = (left, right) => areArraysEqual(left.panGestures, right.panGestures) && areArraysEqual(left.pinchGestures, right.pinchGestures) && areArraysEqual(left.scrollStates, right.scrollStates) && areArraysEqual(left.ownerRouteKeys, right.ownerRouteKeys);
+const getAxisDirections = axis => axis === "vertical" ? ["vertical", "vertical-inverted"] : ["horizontal", "horizontal-inverted"];
+export const createGestureOwnershipCoordinator = topology => {
+  const registrations = new Map();
+  const scrollCache = new Map();
+  const listenersByScreenKey = new Map();
+  const getNearestAncestorOwner = (screenKey, direction) => {
+    const visited = new Set();
+    let candidate = screenKey;
+    while (candidate && !visited.has(candidate)) {
+      visited.add(candidate);
+      if (registrations.get(candidate)?.claimedDirections[direction]) {
+        return candidate;
+      }
+      candidate = topology.getRelationships(candidate).parentScreenKey;
+    }
+    return null;
+  };
+  const getDeepestActiveOwner = (screenKey, direction) => {
+    const visited = new Set();
+    let candidate = screenKey;
+    let owner = null;
+    let isOrigin = true;
+    while (candidate && !visited.has(candidate)) {
+      visited.add(candidate);
+      const registration = registrations.get(candidate);
+      const claims = isOrigin ? registration?.claimedDirections : registration?.effectiveClaimedDirections;
+      if (claims?.[direction]) owner = candidate;
+      candidate = topology.getRelationships(candidate).activeChildScreenKey;
+      isOrigin = false;
+    }
+    return owner;
+  };
+  const resolveOwners = screenKey => {
+    const owners = createEmptyOwners();
+    for (const direction of DIRECTIONS) {
+      owners[direction] = getDeepestActiveOwner(screenKey, direction) ?? getNearestAncestorOwner(screenKey, direction);
+    }
+    return owners;
+  };
+  const resolveScrollCoordination = (screenKey, axis) => {
+    const ownerKeys = [];
+    for (const direction of getAxisDirections(axis)) {
+      const ownerKey = getNearestAncestorOwner(screenKey, direction);
+      if (ownerKey && !ownerKeys.includes(ownerKey)) ownerKeys.push(ownerKey);
+    }
+    const panGestures = [];
+    const scrollStates = [];
+    for (const ownerKey of ownerKeys) {
+      const source = registrations.get(ownerKey)?.source;
+      if (!source) continue;
+      panGestures.push(source.panGesture);
+      scrollStates.push(source.scrollState);
+    }
+    const pinchGestures = [];
+    const visited = new Set();
+    let candidate = screenKey;
+    while (candidate && !visited.has(candidate)) {
+      visited.add(candidate);
+      const pinchGesture = registrations.get(candidate)?.source.pinchGesture;
+      if (pinchGesture && !pinchGestures.includes(pinchGesture)) {
+        pinchGestures.push(pinchGesture);
+      }
+      candidate = topology.getRelationships(candidate).parentScreenKey;
+    }
+    return {
+      panGestures,
+      pinchGestures,
+      scrollStates,
+      ownerRouteKeys: ownerKeys
+    };
+  };
+  const notify = screenKey => {
+    for (const listener of listenersByScreenKey.get(screenKey) ?? []) {
+      listener();
+    }
+  };
+  const recompute = () => {
+    for (const [screenKey, registration] of registrations) {
+      const nextOwners = resolveOwners(screenKey);
+      if (!areOwnersEqual(registration.owners.get(), nextOwners)) {
+        registration.owners.set(nextOwners);
+      }
+      const previousScroll = scrollCache.get(screenKey);
+      const nextScroll = {
+        vertical: resolveScrollCoordination(screenKey, "vertical"),
+        horizontal: resolveScrollCoordination(screenKey, "horizontal")
+      };
+      const vertical = previousScroll && areScrollCoordinationsEqual(previousScroll.vertical, nextScroll.vertical) ? previousScroll.vertical : nextScroll.vertical;
+      const horizontal = previousScroll && areScrollCoordinationsEqual(previousScroll.horizontal, nextScroll.horizontal) ? previousScroll.horizontal : nextScroll.horizontal;
+      if (!previousScroll || vertical !== previousScroll.vertical || horizontal !== previousScroll.horizontal) {
+        scrollCache.set(screenKey, {
+          vertical,
+          horizontal
+        });
+        notify(screenKey);
+      }
+    }
+  };
+  topology.subscribeResolution(recompute);
+  return {
+    register: registration => {
+      registrations.set(registration.screenKey, registration);
+      recompute();
+    },
+    unregister: screenKey => {
+      if (!registrations.has(screenKey)) return;
+      registrations.delete(screenKey);
+      scrollCache.delete(screenKey);
+      recompute();
+      notify(screenKey);
+    },
+    getScrollCoordination: (screenKey, axis) => scrollCache.get(screenKey)?.[axis] ?? EMPTY_SCROLL_COORDINATION,
+    subscribe: (screenKey, listener) => {
+      const listeners = listenersByScreenKey.get(screenKey) ?? new Set();
+      listeners.add(listener);
+      listenersByScreenKey.set(screenKey, listeners);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) listenersByScreenKey.delete(screenKey);
+      };
+    }
+  };
+};
+export const gestureOwnershipCoordinator = createGestureOwnershipCoordinator(screenTopology);
+//# sourceMappingURL=gesture-ownership-coordinator.js.map

package/lib/module/providers/screen/motion/gestures/ownership/gesture-ownership-coordinator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DIRECTIONS","screenTopology","EMPTY_SCROLL_COORDINATION","panGestures","pinchGestures","scrollStates","ownerRouteKeys","createEmptyOwners","vertical","horizontal","areOwnersEqual","left","right","every","direction","areArraysEqual","length","value","index","areScrollCoordinationsEqual","getAxisDirections","axis","createGestureOwnershipCoordinator","topology","registrations","Map","scrollCache","listenersByScreenKey","getNearestAncestorOwner","screenKey","visited","Set","candidate","has","add","get","claimedDirections","getRelationships","parentScreenKey","getDeepestActiveOwner","owner","isOrigin","registration","claims","effectiveClaimedDirections","activeChildScreenKey","resolveOwners","owners","resolveScrollCoordination","ownerKeys","ownerKey","includes","push","source","panGesture","scrollState","pinchGesture","notify","listener","recompute","nextOwners","set","previousScroll","nextScroll","subscribeResolution","register","unregister","delete","getScrollCoordination","subscribe","listeners","size","gestureOwnershipCoordinator"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/ownership/gesture-ownership-coordinator.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/ownership/hooks/use-gesture-sensitivity.js

@@ -0,0 +1,78 @@
+"use strict";
+
+import { useCallback, useMemo } from "react";
+import { useSharedValue } from "react-native-reanimated";
+import { applyGestureSensitivity, normalizePinchScale } from "../../shared/physics";
+export const applyGestureSensitivityToRawChange = (rawValue, sensitivity, state) => {
+  "worklet";
+
+  const rawChange = rawValue - state.previousRawValue.get();
+
+  // gestureSensitivity can change mid-gesture, so apply it to the latest
+  // raw movement only instead of rescaling the recognizer's cumulative value.
+  const adjustedValue = state.adjustedValue.get() + applyGestureSensitivity(rawChange, sensitivity);
+  state.previousRawValue.set(rawValue);
+  state.adjustedValue.set(adjustedValue);
+  return adjustedValue;
+};
+const resetChangeState = state => {
+  "worklet";
+
+  state.previousRawValue.set(0);
+  state.adjustedValue.set(0);
+};
+const useBuildSensitivityChangeState = () => {
+  const previousRawValue = useSharedValue(0);
+  const adjustedValue = useSharedValue(0);
+  return useMemo(() => ({
+    previousRawValue,
+    adjustedValue
+  }), [previousRawValue, adjustedValue]);
+};
+export const usePanGestureSensitivity = screenOptions => {
+  const xSensitivityState = useBuildSensitivityChangeState();
+  const ySensitivityState = useBuildSensitivityChangeState();
+  const resetSensitivity = useCallback(() => {
+    "worklet";
+
+    resetChangeState(xSensitivityState);
+    resetChangeState(ySensitivityState);
+  }, [xSensitivityState, ySensitivityState]);
+  const withSensitivity = useCallback(event => {
+    "worklet";
+
+    const sensitivity = screenOptions.get().gestureSensitivity;
+    return {
+      ...event,
+      translationX: applyGestureSensitivityToRawChange(event.translationX, sensitivity, xSensitivityState),
+      translationY: applyGestureSensitivityToRawChange(event.translationY, sensitivity, ySensitivityState)
+    };
+  }, [screenOptions, xSensitivityState, ySensitivityState]);
+  return useMemo(() => ({
+    withSensitivity,
+    resetSensitivity
+  }), [withSensitivity, resetSensitivity]);
+};
+export const usePinchGestureSensitivity = screenOptions => {
+  const scaleSensitivityState = useBuildSensitivityChangeState();
+  const resetSensitivity = useCallback(() => {
+    "worklet";
+
+    resetChangeState(scaleSensitivityState);
+  }, [scaleSensitivityState]);
+  const withSensitivity = useCallback(event => {
+    "worklet";
+
+    const sensitivity = screenOptions.get().gestureSensitivity;
+    const normScale = applyGestureSensitivityToRawChange(normalizePinchScale(event.scale), sensitivity, scaleSensitivityState);
+    return {
+      ...event,
+      scale: 1 + normScale
+    };
+  }, [screenOptions, scaleSensitivityState]);
+  return useMemo(() => ({
+    withSensitivity,
+    resetSensitivity
+  }), [withSensitivity, resetSensitivity]);
+};
+//# sourceMappingURL=use-gesture-sensitivity.js.map

package/lib/module/providers/screen/motion/gestures/ownership/hooks/use-gesture-sensitivity.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useMemo","useSharedValue","applyGestureSensitivity","normalizePinchScale","applyGestureSensitivityToRawChange","rawValue","sensitivity","state","rawChange","previousRawValue","get","adjustedValue","set","resetChangeState","useBuildSensitivityChangeState","usePanGestureSensitivity","screenOptions","xSensitivityState","ySensitivityState","resetSensitivity","withSensitivity","event","gestureSensitivity","translationX","translationY","usePinchGestureSensitivity","scaleSensitivityState","normScale","scale"],"sourceRoot":"../../../../../../../../src","sources":["providers/screen/motion/gestures/ownership/hooks/use-gesture-sensitivity.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/ownership/hooks/use-screen-gesture-config.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import { useMemo } from "react";
+import { useBuilderStore } from "../../../../builder";
+import { resolveScreenGestureConfig } from "../../shared/policy";
+export function useScreenGestureConfig() {
+  const options = useBuilderStore(store => store.options);
+  const isFirstKey = useBuilderStore(store => store.derivations.isFirstKey);
+  return useMemo(() => resolveScreenGestureConfig({
+    options,
+    isFirstKey
+  }), [isFirstKey, options]);
+}
+//# sourceMappingURL=use-screen-gesture-config.js.map

package/lib/module/providers/screen/motion/gestures/ownership/hooks/use-screen-gesture-config.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useMemo","useBuilderStore","resolveScreenGestureConfig","useScreenGestureConfig","options","store","isFirstKey","derivations"],"sourceRoot":"../../../../../../../../src","sources":["providers/screen/motion/gestures/ownership/hooks/use-screen-gesture-config.ts"],"mappings":";;AAAA,SAASA,OAAO,QAAQ,OAAO;AAC/B,SAASC,eAAe,QAAQ,qBAAqB;AACrD,SAASC,0BAA0B,QAAQ,qBAAqB;AAGhE,OAAO,SAASC,sBAAsBA,CAAA,EAAwB;EAC7D,MAAMC,OAAO,GAAGH,eAAe,CAAEI,KAAK,IAAKA,KAAK,CAACD,OAAO,CAAC;EACzD,MAAME,UAAU,GAAGL,eAAe,CAAEI,KAAK,IAAKA,KAAK,CAACE,WAAW,CAACD,UAAU,CAAC;EAC3E,OAAON,OAAO,CACb,MACCE,0BAA0B,CAAC;IAC1BE,OAAO;IACPE;EACD,CAAC,CAAC,EACH,CAACA,UAAU,EAAEF,OAAO,CACrB,CAAC;AACF","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/ownership/hooks/use-screen-gesture.js

@@ -0,0 +1,25 @@
+"use strict";
+
+import { useResolvedTransitionKey } from "../../../../builder/topology";
+import { useOptionalMotionStore } from "../../..";
+/**
+ * Returns a screen navigation pan gesture.
+ * Use this to coordinate child gestures with the navigation gesture.
+ *
+ * @example
+ * ```tsx
+ * const screenGesture = useScreenGesture();
+ *
+ * const myPanGesture = Gesture.Pan()
+ *   .requireExternalGestureToFail(screenGesture)
+ *   .onUpdate((...) => {});
+ * ```
+ */
+export const useScreenGesture = target => {
+  const localGesture = useOptionalMotionStore(store => store?.gestures ?? null);
+  const usesLocalStore = target === undefined || target.depth === 0;
+  const screenKey = useResolvedTransitionKey(localGesture?.routeKey ?? null, target);
+  const keyedGesture = useOptionalMotionStore(usesLocalStore ? null : screenKey, store => store.gestures.panGesture);
+  return usesLocalStore ? localGesture?.panGesture ?? null : keyedGesture;
+};
+//# sourceMappingURL=use-screen-gesture.js.map

package/lib/module/providers/screen/motion/gestures/ownership/hooks/use-screen-gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useResolvedTransitionKey","useOptionalMotionStore","useScreenGesture","target","localGesture","store","gestures","usesLocalStore","undefined","depth","screenKey","routeKey","keyedGesture","panGesture"],"sourceRoot":"../../../../../../../../src","sources":["providers/screen/motion/gestures/ownership/hooks/use-screen-gesture.ts"],"mappings":";;AAAA,SAASA,wBAAwB,QAAQ,8BAA8B;AACvE,SAASC,sBAAsB,QAAQ,UAAU;AAIjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,gBAAgB,GAAIC,MAA4B,IAAK;EACjE,MAAMC,YAAY,GAAGH,sBAAsB,CACzCI,KAAK,IAAKA,KAAK,EAAEC,QAAQ,IAAI,IAC/B,CAAC;EACD,MAAMC,cAAc,GAAGJ,MAAM,KAAKK,SAAS,IAAIL,MAAM,CAACM,KAAK,KAAK,CAAC;EACjE,MAAMC,SAAS,GAAGV,wBAAwB,CACzCI,YAAY,EAAEO,QAAQ,IAAI,IAAI,EAC9BR,MACD,CAAC;EACD,MAAMS,YAAY,GAAGX,sBAAsB,CAC1CM,cAAc,GAAG,IAAI,GAAGG,SAAS,EAChCL,KAAK,IAAKA,KAAK,CAACC,QAAQ,CAACO,UAC3B,CAAC;EAED,OAAON,cAAc,GAAIH,YAAY,EAAES,UAAU,IAAI,IAAI,GAAID,YAAY;AAC1E,CAAC","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/ownership/hooks/use-stable-runtime-config.js

@@ -0,0 +1,30 @@
+"use strict";
+
+import { useLayoutEffect, useMemo } from "react";
+import { useSharedValue } from "react-native-reanimated";
+export function useStableRuntimeConfig(runtimeConfigInput, values) {
+  const {
+    participation,
+    policy
+  } = runtimeConfigInput;
+  const stores = useMemo(() => {
+    return {
+      gestures: values,
+      animations: values,
+      system: values
+    };
+  }, [values]);
+  const runtimeConfig = useMemo(() => {
+    return {
+      participation,
+      policy,
+      stores
+    };
+  }, [participation, policy, stores]);
+  const stableRuntimeConfig = useSharedValue(runtimeConfig);
+  useLayoutEffect(() => {
+    stableRuntimeConfig.set(runtimeConfig);
+  }, [stableRuntimeConfig, runtimeConfig]);
+  return stableRuntimeConfig;
+}
+//# sourceMappingURL=use-stable-runtime-config.js.map

package/lib/module/providers/screen/motion/gestures/ownership/hooks/use-stable-runtime-config.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useLayoutEffect","useMemo","useSharedValue","useStableRuntimeConfig","runtimeConfigInput","values","participation","policy","stores","gestures","animations","system","runtimeConfig","stableRuntimeConfig","set"],"sourceRoot":"../../../../../../../../src","sources":["providers/screen/motion/gestures/ownership/hooks/use-stable-runtime-config.ts"],"mappings":";;AAAA,SAASA,eAAe,EAAEC,OAAO,QAAQ,OAAO;AAChD,SAA2BC,cAAc,QAAQ,yBAAyB;AAS1E,OAAO,SAASC,sBAAsBA,CACrCC,kBAA+C,EAC/CC,MAAoB,EACmB;EACvC,MAAM;IAAEC,aAAa;IAAEC;EAAO,CAAC,GAAGH,kBAAkB;EAEpD,MAAMI,MAAM,GAAGP,OAAO,CAAC,MAAM;IAC5B,OAAO;MACNQ,QAAQ,EAAEJ,MAAM;MAChBK,UAAU,EAAEL,MAAM;MAClBM,MAAM,EAAEN;IACT,CAAC;EACF,CAAC,EAAE,CAACA,MAAM,CAAC,CAAC;EAEZ,MAAMO,aAAa,GAAGX,OAAO,CAA0B,MAAM;IAC5D,OAAO;MACNK,aAAa;MACbC,MAAM;MACNC;IACD,CAAC;EACF,CAAC,EAAE,CAACF,aAAa,EAAEC,MAAM,EAAEC,MAAM,CAAC,CAAC;EACnC,MAAMK,mBAAmB,GAAGX,cAAc,CAACU,aAAa,CAAC;EAEzDZ,eAAe,CAAC,MAAM;IACrBa,mBAAmB,CAACC,GAAG,CAACF,aAAa,CAAC;EACvC,CAAC,EAAE,CAACC,mBAAmB,EAAED,aAAa,CAAC,CAAC;EAExC,OAAOC,mBAAmB;AAC3B","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/ownership/shadowing-claims.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["resolveShadowingClaimDirections","isCurrentScreenClosing","currentClaimedDirections","previousClaimedDirections"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/ownership/shadowing-claims.ts"],"mappings":";;AAEA,OAAO,MAAMA,+BAA+B,GAAGA,CAAC;EAC/CC,sBAAsB;EACtBC,wBAAwB;EACxBC;AAKD,CAAC,KAAwB;EACxB,IAAIF,sBAAsB,EAAE;IAC3B,OAAOE,yBAAyB;EACjC;EAEA,OAAOD,wBAAwB;AAChC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+"use strict";
+
+import { useCallback, useSyncExternalStore } from "react";
+import { gestureOwnershipCoordinator } from "./gesture-ownership-coordinator";
+export const useGestureScrollCoordination = (screenKey, axis) => {
+  const subscribe = useCallback(listener => screenKey ? gestureOwnershipCoordinator.subscribe(screenKey, listener) : () => {}, [screenKey]);
+  const getSnapshot = useCallback(() => gestureOwnershipCoordinator.getScrollCoordination(screenKey ?? "", axis), [axis, screenKey]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+};
+//# sourceMappingURL=use-gesture-scroll-coordination.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useSyncExternalStore","gestureOwnershipCoordinator","useGestureScrollCoordination","screenKey","axis","subscribe","listener","getSnapshot","getScrollCoordination"],"sourceRoot":"../../../../../../../src","sources":["providers/screen/motion/gestures/ownership/use-gesture-scroll-coordination.ts"],"mappings":";;AAAA,SAASA,WAAW,EAAEC,oBAAoB,QAAQ,OAAO;AAEzD,SAASC,2BAA2B,QAAQ,iCAAiC;AAE7E,OAAO,MAAMC,4BAA4B,GAAGA,CAC3CC,SAAwB,EACxBC,IAAuB,KACnB;EACJ,MAAMC,SAAS,GAAGN,WAAW,CAC3BO,QAAoB,IACpBH,SAAS,GACNF,2BAA2B,CAACI,SAAS,CAACF,SAAS,EAAEG,QAAQ,CAAC,GAC1D,MAAM,CAAC,CAAC,EACZ,CAACH,SAAS,CACX,CAAC;EACD,MAAMI,WAAW,GAAGR,WAAW,CAC9B,MACCE,2BAA2B,CAACO,qBAAqB,CAACL,SAAS,IAAI,EAAE,EAAEC,IAAI,CAAC,EACzE,CAACA,IAAI,EAAED,SAAS,CACjB,CAAC;EAED,OAAOH,oBAAoB,CAACK,SAAS,EAAEE,WAAW,EAAEA,WAAW,CAAC;AACjE,CAAC","ignoreList":[]}

package/lib/module/providers/screen/motion/gestures/pan/activation/pan-activation-decision.js

@@ -0,0 +1,205 @@
+"use strict";
+
+import { EPSILON } from "../../../../../../constants";
+import { GestureActivationState } from "../../../../../../types/gesture.types";
+import { getPanSnapAxisConfigForDirection } from "../../shared/directions";
+import { resolveRuntimeSnapPoints } from "../../shared/snap-points";
+import { checkScrollBoundary, resolveOffsetRules } from "./pan-activation-rules";
+const createDecision = (action, reason, direction, nextActivationState) => {
+  "worklet";
+
+  return {
+    action,
+    reason,
+    direction,
+    nextActivationState
+  };
+};
+const getSwipeDirection = ({
+  isSwipingDown,
+  isSwipingUp,
+  isSwipingRight,
+  isSwipingLeft
+}) => {
+  "worklet";
+
+  if (isSwipingDown) return "vertical";
+  if (isSwipingUp) return "vertical-inverted";
+  if (isSwipingRight) return "horizontal";
+  if (isSwipingLeft) return "horizontal-inverted";
+  return null;
+};
+const resolvePreflightDecision = (event, runtime, ancestorDismissing) => {
+  "worklet";
+
+  if (event.numberOfTouches !== 1) {
+    return createDecision("fail", "multi-touch", null, GestureActivationState.FAILED);
+  }
+  if (ancestorDismissing) {
+    return createDecision("fail", "ancestor-dismissing", null, GestureActivationState.FAILED);
+  }
+  if (!runtime.participation.canTrackGesture || !runtime.policy.enabled) {
+    return createDecision("fail", "disabled", null, GestureActivationState.FAILED);
+  }
+  return null;
+};
+const resolveOffsetFailureDecision = offset => {
+  "worklet";
+
+  if (offset.nextActivationState !== GestureActivationState.FAILED) {
+    return null;
+  }
+  return createDecision("fail", "offset-failed", null, offset.nextActivationState);
+};
+const resolveDirectionGateDecision = (swipeDirection, offset, gestureOwners, currentScreenKey) => {
+  "worklet";
+
+  if (!swipeDirection) {
+    return createDecision("wait", "no-direction", null, offset.nextActivationState);
+  }
+  if (gestureOwners[swipeDirection] !== currentScreenKey) {
+    return createDecision("fail", "ownership", swipeDirection, offset.nextActivationState);
+  }
+  if (offset.nextActivationState !== GestureActivationState.PASSED) {
+    return createDecision("wait", "threshold-pending", swipeDirection, offset.nextActivationState);
+  }
+  return null;
+};
+const resolveSnapLockDecision = (hasSnapPoints, gestureSnapLocked, isExpandGesture, swipeDirection, nextActivationState) => {
+  "worklet";
+
+  if (!hasSnapPoints || !gestureSnapLocked || !isExpandGesture) {
+    return null;
+  }
+  return createDecision("fail", "snap-locked", swipeDirection, nextActivationState);
+};
+const resolveSnapScrollExpansionDecision = (runtime, swipeDirection, nextActivationState) => {
+  "worklet";
+
+  const {
+    participation,
+    policy,
+    stores: {
+      animations,
+      system
+    }
+  } = runtime;
+  const {
+    hasAutoSnapPoint,
+    snapPoints,
+    minSnapPoint,
+    maxSnapPoint
+  } = participation.effectiveSnapPoints;
+  if (policy.sheetScrollGestureBehavior === "collapse-only") {
+    return createDecision("fail", "scroll-collapse-only", swipeDirection, nextActivationState);
+  }
+  const {
+    resolvedMaxSnapPoint
+  } = resolveRuntimeSnapPoints({
+    snapPoints,
+    hasAutoSnapPoint,
+    resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
+    minSnapPoint,
+    maxSnapPoint,
+    canDismiss: participation.canDismiss
+  });
+  const canExpandMore = animations.transitionProgress.get() < resolvedMaxSnapPoint - EPSILON && system.targetProgress.get() < resolvedMaxSnapPoint - EPSILON;
+  if (canExpandMore) {
+    return null;
+  }
+  return createDecision("fail", "scroll-max-expanded", swipeDirection, nextActivationState);
+};
+const resolveDismissingDecision = (hasSnapPoints, isDismissing, swipeDirection, nextActivationState) => {
+  "worklet";
+
+  if (hasSnapPoints || !isDismissing) {
+    return null;
+  }
+  return createDecision("wait", "dismissing", swipeDirection, nextActivationState);
+};
+const isVerticalDirection = direction => {
+  "worklet";
+
+  return direction === "vertical" || direction === "vertical-inverted";
+};
+const resolveUntouchedScrollDecision = (scrollState, swipeDirection, nextActivationState) => {
+  "worklet";
+
+  const axisState = isVerticalDirection(swipeDirection) ? scrollState?.vertical : scrollState?.horizontal;
+  if (axisState?.isTouched ?? false) {
+    return null;
+  }
+  return createDecision("activate", "ready", swipeDirection, nextActivationState);
+};
+const resolveScrollBoundaryDecision = (scrollState, swipeDirection, activeSnapAxis, nextActivationState) => {
+  "worklet";
+
+  const atBoundary = checkScrollBoundary(scrollState, swipeDirection, activeSnapAxis?.config.inverted);
+  if (atBoundary) {
+    return null;
+  }
+  return createDecision("fail", "scroll-boundary", swipeDirection, nextActivationState);
+};
+const resolveScrollDecision = (runtime, scrollState, swipeDirection, activeSnapAxis, isExpandGesture, nextActivationState) => {
+  "worklet";
+
+  const hasSnapPoints = runtime.participation.effectiveSnapPoints.hasSnapPoints;
+  const dismissingDecision = resolveDismissingDecision(hasSnapPoints, Boolean(runtime.stores.gestures.dismissing.get()), swipeDirection, nextActivationState);
+  if (dismissingDecision) return dismissingDecision;
+  const untouchedScrollDecision = resolveUntouchedScrollDecision(scrollState, swipeDirection, nextActivationState);
+  if (untouchedScrollDecision) return untouchedScrollDecision;
+  const activeScrollState = scrollState;
+  const boundaryDecision = resolveScrollBoundaryDecision(activeScrollState, swipeDirection, activeSnapAxis, nextActivationState);
+  if (boundaryDecision) return boundaryDecision;
+  const snapExpandDecision = hasSnapPoints && isExpandGesture ? resolveSnapScrollExpansionDecision(runtime, swipeDirection, nextActivationState) : null;
+  return snapExpandDecision ?? createDecision("activate", "ready", swipeDirection, nextActivationState);
+};
+export const resolvePanActivationMoveDecision = ({
+  event,
+  runtime,
+  dimensions,
+  initialTouch,
+  activationState,
+  ancestorDismissing,
+  gestureOwners,
+  currentScreenKey,
+  scrollState
+}) => {
+  "worklet";
+
+  const preflightDecision = resolvePreflightDecision(event, runtime, ancestorDismissing);
+  if (preflightDecision) return preflightDecision;
+  const {
+    policy
+  } = runtime;
+  const touch = event.changedTouches[0];
+  const offset = resolveOffsetRules({
+    touch,
+    initialTouch,
+    directions: policy.panActivationDirections,
+    dimensions,
+    activationState,
+    activationArea: policy.gestureActivationArea
+  });
+  const offsetFailureDecision = resolveOffsetFailureDecision(offset);
+  if (offsetFailureDecision) return offsetFailureDecision;
+  if (runtime.stores.gestures.dragging.get()) {
+    return createDecision("activate", "already-dragging", null, offset.nextActivationState);
+  }
+  const swipeDirection = getSwipeDirection(offset);
+  const directionGateDecision = resolveDirectionGateDecision(swipeDirection, offset, gestureOwners, currentScreenKey);
+  if (directionGateDecision) return directionGateDecision;
+  const activeDirection = swipeDirection;
+  const {
+    participation
+  } = runtime;
+  const {
+    hasSnapPoints
+  } = participation.effectiveSnapPoints;
+  const activeSnapAxis = hasSnapPoints ? getPanSnapAxisConfigForDirection(policy.snapAxisDirections, activeDirection) : null;
+  const isExpandGesture = activeSnapAxis?.config.expand === activeDirection;
+  const snapLockDecision = resolveSnapLockDecision(hasSnapPoints, policy.gestureSnapLocked, isExpandGesture, activeDirection, offset.nextActivationState);
+  if (snapLockDecision) return snapLockDecision;
+  return resolveScrollDecision(runtime, scrollState, activeDirection, activeSnapAxis, isExpandGesture, offset.nextActivationState);
+};
+//# sourceMappingURL=pan-activation-decision.js.map