@honeypathkar/react-native-predictive-back-gesture 1.0.0

package/android/src/main/java/com/predictiveback/PredictiveBackModule.kt

@@ -0,0 +1,138 @@
+package com.predictiveback
+
+import android.os.Build
+import android.util.Log
+import androidx.activity.ComponentActivity
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.BackEventCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class PredictiveBackModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val backCallback = object : OnBackPressedCallback(false) {
+        override fun handleOnBackStarted(backEvent: BackEventCompat) {
+            emit(EVENT_START, backEvent.toEventMap())
+        }
+        override fun handleOnBackProgressed(backEvent: BackEventCompat) {
+            emit(EVENT_PROGRESS, backEvent.toEventMap())
+        }
+        override fun handleOnBackCancelled() {
+            emit(EVENT_CANCEL, Arguments.createMap())
+        }
+        override fun handleOnBackPressed() {
+            emit(EVENT_COMMIT, Arguments.createMap())
+        }
+    }
+
+    private var isRegistered = false
+    private var reactCallback: OnBackPressedCallback? = null
+    private var reactCallbackHost: ComponentActivity? = null
+
+    override fun getName(): String = NAME
+
+    override fun getConstants(): MutableMap<String, Any> =
+        hashMapOf(
+            "progressAvailable" to (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+        )
+
+    @ReactMethod
+    fun setMode(mode: String) {
+        UiThreadUtil.runOnUiThread {
+            val activity = reactApplicationContext.currentActivity as? ComponentActivity
+            when (mode) {
+                MODE_APP -> {
+                    if (activity != null) {
+                        attachTo(activity)
+                        setReactCallbackEnabled(activity, true)
+                    }
+                    backCallback.isEnabled = true
+                }
+                MODE_SYSTEM -> {
+                    backCallback.isEnabled = false
+                    if (activity != null) setReactCallbackEnabled(activity, false)
+                }
+                MODE_DEFAULT -> {
+                    backCallback.isEnabled = false
+                    if (activity != null) setReactCallbackEnabled(activity, true)
+                }
+                else -> Log.w(NAME, "Unknown back mode: $mode")
+            }
+        }
+    }
+
+    @ReactMethod fun addListener(eventName: String) = Unit
+    @ReactMethod fun removeListeners(count: Int) = Unit
+
+    override fun invalidate() {
+        UiThreadUtil.runOnUiThread {
+            backCallback.isEnabled = false
+            if (isRegistered) { backCallback.remove(); isRegistered = false }
+            reactCallback?.isEnabled = true
+            reactCallback = null
+            reactCallbackHost = null
+        }
+        super.invalidate()
+    }
+
+    private fun attachTo(activity: ComponentActivity) {
+        if (isRegistered) backCallback.remove()
+        activity.onBackPressedDispatcher.addCallback(backCallback)
+        isRegistered = true
+    }
+
+    private fun setReactCallbackEnabled(activity: ComponentActivity, enabled: Boolean) {
+        findReactCallback(activity)?.isEnabled = enabled
+    }
+
+    private fun findReactCallback(activity: ComponentActivity): OnBackPressedCallback? {
+        if (reactCallbackHost === activity) return reactCallback
+        var cls: Class<*>? = activity.javaClass
+        while (cls != null && cls != ComponentActivity::class.java) {
+            for (field in cls.declaredFields) {
+                if (OnBackPressedCallback::class.java.isAssignableFrom(field.type)) {
+                    try {
+                        field.isAccessible = true
+                        val found = field.get(activity) as? OnBackPressedCallback
+                        if (found != null) {
+                            reactCallback = found; reactCallbackHost = activity
+                            return found
+                        }
+                    } catch (e: Exception) {
+                        Log.w(NAME, "Could not read React Native's back callback", e)
+                        return null
+                    }
+                }
+            }
+            cls = cls.superclass
+        }
+        Log.w(NAME, "React Native's back callback not found; system back mode is a no-op")
+        return null
+    }
+
+    private fun emit(event: String, payload: WritableMap) {
+        val context = reactApplicationContext
+        if (!context.hasActiveReactInstance()) return
+        context.emitDeviceEvent(event, payload)
+    }
+
+    private fun BackEventCompat.toEventMap(): WritableMap =
+        Arguments.createMap().apply {
+            putDouble("progress", progress.toDouble())
+            putInt("swipeEdge", swipeEdge)        // 0 = left, 1 = right
+            putDouble("touchX", touchX.toDouble())
+            putDouble("touchY", touchY.toDouble())
+        }
+
+    companion object {
+        const val NAME = "PredictiveBackModule"
+        private const val MODE_APP     = "app"
+        private const val MODE_DEFAULT = "default"
+        private const val MODE_SYSTEM  = "system"
+        private const val EVENT_START    = "predictiveBackStart"
+        private const val EVENT_PROGRESS = "predictiveBackProgress"
+        private const val EVENT_CANCEL   = "predictiveBackCancel"
+        private const val EVENT_COMMIT   = "predictiveBackCommit"
+    }
+}

package/android/src/main/java/com/predictiveback/PredictiveBackPackage.kt

@@ -0,0 +1,16 @@
+package com.predictiveback
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PredictiveBackPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(PredictiveBackModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/lib/commonjs/AppNavigator.js

@@ -0,0 +1,12 @@
+"use strict";
+// Add this code inside your file where you have declared all the screens navigation or in the App.jsx
+Object.defineProperty(exports, "__esModule", { value: true });
+const PredictiveBack_1 = require("../native/PredictiveBack");
+// Inside the AppNavigator component:
+const syncBackMode = React.useCallback(() => {
+    (0, PredictiveBack_1.setFallbackBackMode)(navigationRef.isReady() && navigationRef.canGoBack()
+        ? PredictiveBack_1.BACK_MODE_DEFAULT
+        : PredictiveBack_1.BACK_MODE_SYSTEM);
+}, []);
+// On the NavigationContainer:
+<NavigationContainer ref={navigationRef} onReady={syncBackMode} onStateChange={syncBackMode}></NavigationContainer>;

package/lib/commonjs/PredectiveBack.js

@@ -0,0 +1,85 @@
+"use strict";
+// src/native/PredictiveBack.js — New File (JS Bridge + Ownership Model)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePredictiveBack = exports.acquirePredictiveBack = exports.setFallbackBackMode = exports.BACK_MODE_SYSTEM = exports.BACK_MODE_DEFAULT = exports.EDGE_RIGHT = exports.EDGE_LEFT = exports.PREDICTIVE_BACK_HAS_PROGRESS = exports.PREDICTIVE_BACK_SUPPORTED = void 0;
+// Create at src/native/PredictiveBack.js (adapt path to your project).
+const react_native_1 = require("react-native");
+const PredictiveBackModule = react_native_1.Platform.OS === 'android' ? react_native_1.NativeModules.PredictiveBackModule : null;
+/** True when the native back-event bridge is present (Android only). */
+exports.PREDICTIVE_BACK_SUPPORTED = PredictiveBackModule != null;
+/**
+ * True when the OS also reports live gesture progress (Android 14 / API 34+).
+ * Below that only the commit arrives — callers should play a timed animation.
+ */
+exports.PREDICTIVE_BACK_HAS_PROGRESS = exports.PREDICTIVE_BACK_SUPPORTED && PredictiveBackModule.progressAvailable === true;
+exports.EDGE_LEFT = 0;
+exports.EDGE_RIGHT = 1;
+/** Back is React Native's to handle (BackHandler + React Navigation). */
+exports.BACK_MODE_DEFAULT = 'default';
+/**
+ * Nothing in the app claims back → Android plays its own back-to-home animation.
+ * Set this at the root of the stack (nothing to go back to).
+ */
+exports.BACK_MODE_SYSTEM = 'system';
+let owner = null;
+let handlers = null;
+let fallbackMode = exports.BACK_MODE_DEFAULT;
+let appliedMode = null;
+let subscriptions = null;
+const apply = () => {
+    const mode = owner ? 'app' : fallbackMode;
+    if (mode === appliedMode)
+        return;
+    appliedMode = mode;
+    PredictiveBackModule.setMode(mode);
+};
+const dispatch = (name, event) => {
+    const handler = handlers && handlers[name];
+    if (handler)
+        handler(event);
+};
+const ensureSubscribed = () => {
+    if (subscriptions || !PredictiveBackModule)
+        return;
+    const emitter = new react_native_1.NativeEventEmitter(PredictiveBackModule);
+    subscriptions = [
+        emitter.addListener('predictiveBackStart', e => dispatch('onStart', e)),
+        emitter.addListener('predictiveBackProgress', e => dispatch('onProgress', e)),
+        emitter.addListener('predictiveBackCancel', () => dispatch('onCancel')),
+        emitter.addListener('predictiveBackCommit', () => dispatch('onCommit')),
+    ];
+};
+/**
+ * What happens when no screen has claimed back.
+ * Call from navigator on state change.
+ */
+const setFallbackBackMode = mode => {
+    if (!PredictiveBackModule || fallbackMode === mode)
+        return;
+    fallbackMode = mode;
+    apply();
+};
+exports.setFallbackBackMode = setFallbackBackMode;
+/**
+ * Route back events to `nextHandlers` and enable the native callback.
+ * `token` is any stable object (e.g. useRef({}).current) that identifies the caller.
+ */
+const acquirePredictiveBack = (token, nextHandlers) => {
+    if (!PredictiveBackModule)
+        return;
+    ensureSubscribed();
+    owner = token;
+    handlers = nextHandlers;
+    appliedMode = null; // force re-apply even if mode string unchanged
+    apply();
+};
+exports.acquirePredictiveBack = acquirePredictiveBack;
+/** Give back control, but only if `token` still holds it. */
+const releasePredictiveBack = token => {
+    if (!PredictiveBackModule || owner !== token)
+        return;
+    owner = null;
+    handlers = null;
+    apply();
+};
+exports.releasePredictiveBack = releasePredictiveBack;

package/lib/commonjs/SwipableScreen.js

@@ -0,0 +1,254 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const react_native_reanimated_1 = __importStar(require("react-native-reanimated"));
+const native_1 = require("@react-navigation/native");
+const react_native_paper_1 = require("react-native-paper");
+const PredectiveBack_1 = require("./PredectiveBack");
+const { width, height } = react_native_1.Dimensions.get("window");
+// Material predictive-back peek: the card shrinks and drifts a little way to the right
+// while the gesture is in flight, revealing the screen underneath. It only leaves the
+// screen once the user commits.
+const MAX_SCALE_DOWN = 0.13;
+const MAX_PEEK_X = width * 0.12;
+const MAX_PEEK_Y = height * 0.03;
+const CORNER_RADIUS = 32;
+const MAX_DIM = 0.5;
+// Screens enter from the right and leave back to the right — the exit always mirrors
+// the entry, whichever edge the gesture came from.
+const ENTER_DURATION = 280;
+const EXIT_DURATION = 240;
+const EASING = react_native_reanimated_1.Easing.out(react_native_reanimated_1.Easing.bezierFn(0.25, 0.46, 0.45, 0.94));
+const SPRING = { damping: 28, stiffness: 260, mass: 0.85 };
+// Drag gesture: how far the finger travels for a full peek, and what commits it.
+const EDGE_WIDTH = 60;
+// Keeps the strip clear of the header, so the back button stays tappable.
+const HEADER_INSET = 75;
+const DRAG_RANGE = width * 0.6;
+const PEEK_THRESHOLD = 0.35;
+const VELOCITY_THRESHOLD = 900;
+const MIN_VELOCITY_DISTANCE = 50;
+const SwipeableScreen = ({ children, enabled = true, style, onHaptic }) => {
+    const navigation = (0, native_1.useNavigation)();
+    const theme = (0, react_native_paper_1.useTheme)();
+    // Gesture progress (0…1) — drives the peek: shrink, drift right, rounded corners.
+    const peek = (0, react_native_reanimated_1.useSharedValue)(0);
+    // Dismissal progress (0…1) — slides the card clear to the right. Also runs in
+    // reverse on mount so the entry mirrors the exit.
+    const exit = (0, react_native_reanimated_1.useSharedValue)(1);
+    // -1…1, how far the touch sits above/below centre; tilts the peek vertically.
+    const pivot = (0, react_native_reanimated_1.useSharedValue)(0);
+    // Set while the OS gesture owns the animation, so the pan cannot drive it too.
+    const nativeActive = (0, react_native_reanimated_1.useSharedValue)(0);
+    // Guards against a second back event landing while the exit animation is running.
+    const isDismissing = (0, react_1.useRef)(false);
+    // ─── Mount: slide in from the right ─────────────────────────────────────
+    (0, react_1.useEffect)(() => {
+        exit.value = (0, react_native_reanimated_1.withTiming)(0, { duration: ENTER_DURATION, easing: EASING });
+    }, [exit]);
+    // ─── JS-thread helpers ───────────────────────────────────────────────────
+    const fireHaptic = (0, react_1.useCallback)(() => {
+        try {
+            if (onHaptic)
+                onHaptic();
+        }
+        catch (e) { }
+    }, [onHaptic]);
+    const settle = (0, react_1.useCallback)(() => {
+        // Put the card back at rest — used when a pop is refused or cancelled.
+        isDismissing.current = false;
+        nativeActive.value = 0;
+        peek.value = (0, react_native_reanimated_1.withTiming)(0, { duration: 160, easing: EASING });
+        exit.value = (0, react_native_reanimated_1.withTiming)(0, { duration: 200, easing: EASING });
+    }, [peek, exit, nativeActive]);
+    const goBack = (0, react_1.useCallback)(() => {
+        if (!navigation.canGoBack()) {
+            settle();
+            return;
+        }
+        navigation.goBack();
+        // goBack dispatches through `beforeRemove`, so it may not actually pop.
+        requestAnimationFrame(() => {
+            if (navigation.isFocused()) {
+                settle();
+            }
+        });
+    }, [navigation, settle]);
+    // ─── Commit / cancel ─────────────────────────────────────────────────────
+    const commit = (0, react_1.useCallback)((duration = EXIT_DURATION) => {
+        if (isDismissing.current) {
+            return;
+        }
+        isDismissing.current = true;
+        fireHaptic();
+        (0, react_native_reanimated_1.cancelAnimation)(exit);
+        exit.value = (0, react_native_reanimated_1.withTiming)(1, { duration, easing: EASING }, (finished) => {
+            "worklet";
+            if (finished) {
+                (0, react_native_reanimated_1.runOnJS)(goBack)();
+            }
+        });
+    }, [exit, fireHaptic, goBack]);
+    const cancel = (0, react_1.useCallback)(() => {
+        nativeActive.value = 0;
+        (0, react_native_reanimated_1.cancelAnimation)(peek);
+        peek.value = (0, react_native_reanimated_1.withSpring)(0, SPRING);
+    }, [peek, nativeActive]);
+    // ─── System back gesture (Android) ───────────────────────────────────────
+    const token = (0, react_1.useRef)({}).current;
+    const isActive = enabled && navigation.canGoBack();
+    (0, native_1.useFocusEffect)((0, react_1.useCallback)(() => {
+        if (!PredectiveBack_1.PREDICTIVE_BACK_SUPPORTED || !isActive) {
+            return undefined;
+        }
+        const track = (event) => {
+            peek.value = event.progress;
+            pivot.value = (event.touchY / height) * 2 - 1;
+        };
+        (0, PredectiveBack_1.acquirePredictiveBack)(token, {
+            onStart: (event) => {
+                if (isDismissing.current) {
+                    return;
+                }
+                nativeActive.value = 1;
+                (0, react_native_reanimated_1.cancelAnimation)(peek);
+                track(event);
+            },
+            onProgress: (event) => {
+                if (!isDismissing.current) {
+                    track(event);
+                }
+            },
+            onCancel: cancel,
+            // Without live progress (pre-Android 14, or a 3-button back press) the card
+            // has not moved yet, so give the slide-out a little more room to breathe.
+            onCommit: () => commit(PredectiveBack_1.PREDICTIVE_BACK_HAS_PROGRESS ? EXIT_DURATION : ENTER_DURATION),
+        });
+        return () => (0, PredectiveBack_1.releasePredictiveBack)(token);
+    }, [token, isActive, peek, pivot, nativeActive, cancel, commit]));
+    // ─── Drag-to-close from the left edge ────────────────────────────────────
+    // On Android this covers the strip just inside the system gesture zone; on iOS it
+    // is the only way back. Both drive the same peek, so the card looks identical
+    // however the gesture arrived.
+    const panGesture = react_native_gesture_handler_1.Gesture.Pan()
+        .enabled(isActive)
+        .hitSlop({ left: 0, width: EDGE_WIDTH, top: -HEADER_INSET })
+        .activeOffsetX([10, 500])
+        .failOffsetY([-18, 18])
+        .onBegin(() => {
+        "worklet";
+        if (nativeActive.value) {
+            return;
+        }
+        (0, react_native_reanimated_1.cancelAnimation)(peek);
+    })
+        .onUpdate((event) => {
+        "worklet";
+        if (nativeActive.value || event.translationX <= 0) {
+            return;
+        }
+        peek.value = Math.min(event.translationX / DRAG_RANGE, 1);
+        pivot.value = (event.y / height) * 2 - 1;
+    })
+        .onEnd((event) => {
+        "worklet";
+        if (nativeActive.value) {
+            return;
+        }
+        const { translationX, velocityX } = event;
+        const shouldCommit = peek.value > PEEK_THRESHOLD ||
+            (velocityX > VELOCITY_THRESHOLD &&
+                translationX > MIN_VELOCITY_DISTANCE);
+        if (shouldCommit) {
+            (0, react_native_reanimated_1.runOnJS)(commit)(velocityX > VELOCITY_THRESHOLD ? 160 : EXIT_DURATION);
+        }
+        else {
+            peek.value = (0, react_native_reanimated_1.withSpring)(0, SPRING);
+        }
+    });
+    // ─── Card ────────────────────────────────────────────────────────────────
+    const screenStyle = (0, react_native_reanimated_1.useAnimatedStyle)(() => {
+        const p = peek.value;
+        return {
+            transform: [
+                { translateX: p * MAX_PEEK_X + exit.value * width },
+                { translateY: pivot.value * p * MAX_PEEK_Y },
+                { scale: 1 - MAX_SCALE_DOWN * p },
+            ],
+            borderRadius: (0, react_native_reanimated_1.interpolate)(p, [0, 0.05, 1], [0, CORNER_RADIUS, CORNER_RADIUS], react_native_reanimated_1.Extrapolation.CLAMP),
+            overflow: "hidden",
+        };
+    });
+    // Dims the screen underneath (visible because the navigator presents screens as
+    // transparent modals) and clears as this card moves out of the way.
+    const backdropStyle = (0, react_native_reanimated_1.useAnimatedStyle)(() => {
+        const revealed = Math.max(peek.value, exit.value);
+        return {
+            opacity: (0, react_native_reanimated_1.interpolate)(revealed, [0, 1], [MAX_DIM, 0], react_native_reanimated_1.Extrapolation.CLAMP),
+        };
+    });
+    return (<react_native_1.View style={styles.outerWrapper}>
+      <react_native_reanimated_1.default.View pointerEvents="none" style={[styles.backdrop, backdropStyle]}/>
+
+      <react_native_gesture_handler_1.GestureDetector gesture={panGesture}>
+        <react_native_reanimated_1.default.View style={[
+            styles.screen,
+            { backgroundColor: theme.colors.background },
+            screenStyle,
+            style,
+        ]}>
+          {children}
+        </react_native_reanimated_1.default.View>
+      </react_native_gesture_handler_1.GestureDetector>
+    </react_native_1.View>);
+};
+exports.default = SwipeableScreen;
+const styles = react_native_1.StyleSheet.create({
+    outerWrapper: {
+        flex: 1,
+    },
+    backdrop: {
+        ...react_native_1.StyleSheet.absoluteFillObject,
+        backgroundColor: "#000000",
+        zIndex: 0,
+    },
+    screen: {
+        flex: 1,
+        zIndex: 1,
+    },
+});

package/lib/commonjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePredictiveBack = exports.acquirePredictiveBack = exports.setFallbackBackMode = exports.BACK_MODE_SYSTEM = exports.BACK_MODE_DEFAULT = exports.EDGE_RIGHT = exports.EDGE_LEFT = exports.PREDICTIVE_BACK_HAS_PROGRESS = exports.PREDICTIVE_BACK_SUPPORTED = exports.SwipeableScreen = void 0;
+const SwipableScreen_1 = __importDefault(require("./SwipableScreen"));
+exports.SwipeableScreen = SwipableScreen_1.default;
+const PredectiveBack_1 = require("./PredectiveBack");
+Object.defineProperty(exports, "PREDICTIVE_BACK_SUPPORTED", { enumerable: true, get: function () { return PredectiveBack_1.PREDICTIVE_BACK_SUPPORTED; } });
+Object.defineProperty(exports, "PREDICTIVE_BACK_HAS_PROGRESS", { enumerable: true, get: function () { return PredectiveBack_1.PREDICTIVE_BACK_HAS_PROGRESS; } });
+Object.defineProperty(exports, "EDGE_LEFT", { enumerable: true, get: function () { return PredectiveBack_1.EDGE_LEFT; } });
+Object.defineProperty(exports, "EDGE_RIGHT", { enumerable: true, get: function () { return PredectiveBack_1.EDGE_RIGHT; } });
+Object.defineProperty(exports, "BACK_MODE_DEFAULT", { enumerable: true, get: function () { return PredectiveBack_1.BACK_MODE_DEFAULT; } });
+Object.defineProperty(exports, "BACK_MODE_SYSTEM", { enumerable: true, get: function () { return PredectiveBack_1.BACK_MODE_SYSTEM; } });
+Object.defineProperty(exports, "setFallbackBackMode", { enumerable: true, get: function () { return PredectiveBack_1.setFallbackBackMode; } });
+Object.defineProperty(exports, "acquirePredictiveBack", { enumerable: true, get: function () { return PredectiveBack_1.acquirePredictiveBack; } });
+Object.defineProperty(exports, "releasePredictiveBack", { enumerable: true, get: function () { return PredectiveBack_1.releasePredictiveBack; } });
+exports.default = SwipableScreen_1.default;

package/lib/commonjs/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../src/appnavigator.jsx","../../src/predectiveback.js","../../src/swipablescreen.jsx","../../src/index.js"],"version":"5.9.3"}

package/lib/typescript/AppNavigator.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/typescript/PredectiveBack.d.ts

@@ -0,0 +1,19 @@
+/** True when the native back-event bridge is present (Android only). */
+export const PREDICTIVE_BACK_SUPPORTED: boolean;
+/**
+ * True when the OS also reports live gesture progress (Android 14 / API 34+).
+ * Below that only the commit arrives — callers should play a timed animation.
+ */
+export const PREDICTIVE_BACK_HAS_PROGRESS: boolean;
+export const EDGE_LEFT: 0;
+export const EDGE_RIGHT: 1;
+/** Back is React Native's to handle (BackHandler + React Navigation). */
+export const BACK_MODE_DEFAULT: "default";
+/**
+ * Nothing in the app claims back → Android plays its own back-to-home animation.
+ * Set this at the root of the stack (nothing to go back to).
+ */
+export const BACK_MODE_SYSTEM: "system";
+export function setFallbackBackMode(mode: any): void;
+export function acquirePredictiveBack(token: any, nextHandlers: any): void;
+export function releasePredictiveBack(token: any): void;

package/lib/typescript/SwipableScreen.d.ts

@@ -0,0 +1,8 @@
+export default SwipeableScreen;
+declare function SwipeableScreen({ children, enabled, style, onHaptic }: {
+    children: any;
+    enabled?: boolean;
+    style: any;
+    onHaptic: any;
+}): React.JSX.Element;
+import React from "react";

package/lib/typescript/index.d.ts

@@ -0,0 +1,12 @@
+export default SwipeableScreen;
+import SwipeableScreen from './SwipableScreen';
+import { PREDICTIVE_BACK_SUPPORTED } from './PredectiveBack';
+import { PREDICTIVE_BACK_HAS_PROGRESS } from './PredectiveBack';
+import { EDGE_LEFT } from './PredectiveBack';
+import { EDGE_RIGHT } from './PredectiveBack';
+import { BACK_MODE_DEFAULT } from './PredectiveBack';
+import { BACK_MODE_SYSTEM } from './PredectiveBack';
+import { setFallbackBackMode } from './PredectiveBack';
+import { acquirePredictiveBack } from './PredectiveBack';
+import { releasePredictiveBack } from './PredectiveBack';
+export { SwipeableScreen, PREDICTIVE_BACK_SUPPORTED, PREDICTIVE_BACK_HAS_PROGRESS, EDGE_LEFT, EDGE_RIGHT, BACK_MODE_DEFAULT, BACK_MODE_SYSTEM, setFallbackBackMode, acquirePredictiveBack, releasePredictiveBack };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@honeypathkar/react-native-predictive-back-gesture",
+  "version": "1.0.0",
+  "description": "Android 14+ Predictive Back gesture animations and swipeable screen component for React Native.",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "files": [
+    "src",
+    "lib",
+    "android/src",
+    "android/build.gradle",
+    "react-native-predictive-back-gesture.podspec",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc --build",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "react-native",
+    "predictive-back",
+    "android-14",
+    "gesture",
+    "swipeable-screen",
+    "reanimated"
+  ],
+  "author": "honeypathkar",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-gesture-handler": "*",
+    "react-native-reanimated": "*"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.31",
+    "react": "^18.2.0",
+    "react-native": "^0.72.0",
+    "react-native-gesture-handler": "^2.12.0",
+    "react-native-reanimated": "^3.3.0",
+    "typescript": "^5.9.3"
+  }
+}

package/react-native-predictive-back-gesture.podspec

@@ -0,0 +1,19 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-predictive-back-gesture"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://github.com/honeypathkar/react-native-predictive-back-gesture"
+  s.license      = "MIT"
+  s.author       = { package["author"] => package["author"] }
+  s.platforms    = { :ios => "12.0" }
+  s.source       = { :git => "https://github.com/honeypathkar/react-native-predictive-back-gesture.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.requires_arc = true
+
+  s.dependency "React-Core"
+end

package/src/AppNavigator.jsx

@@ -0,0 +1,23 @@
+// Add this code inside your file where you have declared all the screens navigation or in the App.jsx
+
+import {
+  BACK_MODE_DEFAULT,
+  BACK_MODE_SYSTEM,
+  setFallbackBackMode,
+} from "../native/PredictiveBack";
+
+// Inside the AppNavigator component:
+const syncBackMode = React.useCallback(() => {
+  setFallbackBackMode(
+    navigationRef.isReady() && navigationRef.canGoBack()
+      ? BACK_MODE_DEFAULT
+      : BACK_MODE_SYSTEM,
+  );
+}, []);
+
+// On the NavigationContainer:
+<NavigationContainer
+  ref={navigationRef}
+  onReady={syncBackMode}
+  onStateChange={syncBackMode}
+></NavigationContainer>;