rn-app-exit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 pixelcube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,241 @@
+# rn-app-exit
+
+> Exit or background your React Native app — with full **New Architecture (TurboModules)** support, written in **Kotlin** and **Objective-C++**.
+
+[![npm version](https://img.shields.io/npm/v/rn-app-exit.svg)](https://www.npmjs.com/package/rn-app-exit)
+[![npm downloads](https://img.shields.io/npm/dm/rn-app-exit.svg)](https://www.npmjs.com/package/rn-app-exit)
+[![license](https://img.shields.io/npm/l/rn-app-exit.svg)](LICENSE)
+[![platform](https://img.shields.io/badge/platform-android%20%7C%20ios-lightgrey.svg)](https://reactnative.dev)
+
+---
+
+## Why this package?
+
+Most apps eventually need one of two things:
+
+- **Hard exit** — a logout button, a kiosk reset, a session wipe that kills the process
+- **Background** — a "minimize" button, a back-to-home UX without killing the process
+
+The original `react-native-exit-app` only does the first, is written in Java/Objective-C, has no TurboModule support, and hasn't been maintained since 2021. This package does both, properly.
+
+---
+
+## Features
+
+| | react-native-exit-app | **react-native-app-exit** |
+|---|---|---|
+| Exit app | ✅ | ✅ |
+| Send to background | ❌ | ✅ |
+| Unified API | ❌ | ✅ |
+| Capability flags | ❌ | ✅ |
+| New Architecture (TurboModules) | ❌ | ✅ |
+| Old Architecture | ✅ | ✅ |
+| Language | Java / ObjC | **Kotlin / ObjC++** |
+| Active maintenance | ❌ (2021) | ✅ |
+| Min React Native | 0.60 | 0.68 |
+
+---
+
+## Installation
+
+```sh
+npm install rn-app-exit
+```
+
+### iOS
+
+```sh
+cd ios && pod install
+```
+
+### Android
+
+No additional steps — auto-linked via React Native's autolinking.
+
+---
+
+## Usage
+
+```tsx
+import AppExit from 'rn-app-exit';
+```
+
+### Hard exit (kill the process)
+
+```tsx
+AppExit.exitApp();
+```
+
+Terminates the app process immediately. The app is removed from recents on Android. On iOS, use this only for non-App-Store builds (kiosks, enterprise, dev tooling) — Apple's HIG discourages `exit()` in consumer App Store apps.
+
+### Send to background (keep process alive)
+
+```tsx
+AppExit.sendToBackground();
+```
+
+Moves the app to the background without terminating. The process stays alive in memory — the user can resume from the app switcher exactly where they left off.
+
+- **Android**: calls `moveTaskToBack(true)` — native OS feature, fully reliable
+- **iOS**: suspends via `UIApplication suspend` selector — works across all current iOS versions
+
+### Unified API
+
+```tsx
+// Hard exit (default)
+AppExit.exit();
+
+// Background instead of kill
+AppExit.exit({ background: true });
+```
+
+The `exit()` method is the recommended API for most use cases. Pass `{ background: true }` to move to background instead of killing.
+
+### Check capability at runtime
+
+```tsx
+if (AppExit.isBackgroundSupported) {
+  // Android: always true
+  // iOS: false — backgrounding is OS-controlled
+  AppExit.sendToBackground();
+} else {
+  AppExit.sendToBackground(); // still works on iOS via best-effort suspend
+}
+```
+
+---
+
+## API Reference
+
+### `AppExit.exit(options?)`
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `options.background` | `boolean` | `false` | When `true`, sends to background instead of killing |
+
+### `AppExit.exitApp()`
+
+Kills the process.
+
+| Platform | Implementation |
+|---|---|
+| Android | `activity.finish()` + `Process.killProcess(myPid())` |
+| iOS | `exit(0)` |
+
+> **iOS warning:** Apple's App Store review guidelines discourage programmatic exit. Prefer `sendToBackground()` in consumer iOS apps.
+
+### `AppExit.sendToBackground()`
+
+Moves the app to the background without terminating the process.
+
+| Platform | Implementation |
+|---|---|
+| Android | `activity.moveTaskToBack(true)` |
+| iOS | `UIApplication` suspend selector |
+
+### `AppExit.isBackgroundSupported`
+
+`boolean` — `true` on Android, `false` on iOS.
+
+On Android, `moveTaskToBack` is a first-class OS feature. On iOS, backgrounding is managed by the OS and there is no public API — the package uses a best-effort approach that works on current iOS versions but is not a documented public API.
+
+---
+
+## TypeScript
+
+Full TypeScript support is included. The exported types are:
+
+```ts
+type AppExitOptions = {
+  background?: boolean;
+};
+```
+
+---
+
+## Platform notes
+
+### Android
+
+All three methods work as expected on Android API 21+. `sendToBackground()` behaves exactly like pressing the Home button — the task moves to the back stack and the process continues running.
+
+### iOS
+
+Apple does not provide a public API for programmatic backgrounding or exit in App Store apps. This package provides:
+
+- `exitApp()` via `exit(0)` — works, but risks App Store rejection for consumer apps. Safe for enterprise/kiosk/dev builds.
+- `sendToBackground()` via `UIApplication` suspend — has been stable across iOS versions and does not trigger App Store rejection the way `exit()` can.
+
+For App Store consumer apps, the recommended pattern is:
+
+```tsx
+// Show a "goodbye" screen or navigate home, then suspend
+AppExit.sendToBackground();
+```
+
+---
+
+## New Architecture
+
+This package supports React Native's New Architecture (TurboModules) out of the box. The JavaScript spec in `src/NativeAppExit.ts` is used by React Native's codegen to generate native bindings automatically.
+
+No additional configuration is needed. The package detects the active architecture at build time and uses the appropriate native implementation.
+
+---
+
+## Common use cases
+
+**Logout button that wipes state and exits:**
+```tsx
+async function handleLogout() {
+  await clearUserSession();
+  AppExit.exitApp();
+}
+```
+
+**Kiosk reset button:**
+```tsx
+function KioskResetButton() {
+  return (
+    <Pressable onPress={() => AppExit.exit()}>
+      <Text>Reset Kiosk</Text>
+    </Pressable>
+  );
+}
+```
+
+**Minimize button (Android UX pattern):**
+```tsx
+function MinimizeButton() {
+  return (
+    <Pressable onPress={() => AppExit.sendToBackground()}>
+      <Text>Go to Home</Text>
+    </Pressable>
+  );
+}
+```
+
+**Hardware back button on Android to background instead of exit:**
+```tsx
+import { BackHandler } from 'react-native';
+
+useEffect(() => {
+  const sub = BackHandler.addEventListener('hardwareBackPress', () => {
+    AppExit.sendToBackground();
+    return true; // prevent default back behavior
+  });
+  return () => sub.remove();
+}, []);
+```
+
+---
+
+## License
+
+MIT © 2025 pixelcube
+
+---
+
+## Contributing
+
+Issues and PRs welcome at [github.com/pixelcube/rn-app-exit](https://github.com/pixelcube/rn-app-exit).

package/android/build.gradle

@@ -0,0 +1,65 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.1.0"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.24"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+android {
+  compileSdkVersion 34
+  namespace "com.appexitlib"
+
+  defaultConfig {
+    minSdkVersion 21
+    targetSdkVersion 34
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += ["src/newarch"]
+      } else {
+        java.srcDirs += ["src/oldarch"]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/appexitlib/AppExitModule.kt

@@ -0,0 +1,32 @@
+package com.appexitlib
+
+import android.os.Process
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = AppExitModule.NAME)
+class AppExitModule(reactContext: ReactApplicationContext) : NativeAppExitSpec(reactContext) {
+
+  override fun getName(): String = NAME
+
+  override fun getConstants(): Map<String, Any> = mapOf(
+    "isBackgroundSupported" to true
+  )
+
+  override fun exitApp() {
+    // Finish the current activity first so the OS doesn't relaunch it,
+    // then kill the process to ensure a clean exit on all Android versions.
+    currentActivity?.finish()
+    Process.killProcess(Process.myPid())
+  }
+
+  override fun sendToBackground() {
+    // moveTaskToBack moves the entire task (all activities in the back stack)
+    // to the background. The process lives on — the user can resume from recents.
+    currentActivity?.moveTaskToBack(true)
+  }
+
+  companion object {
+    const val NAME = "AppExit"
+  }
+}

package/android/src/main/java/com/appexitlib/AppExitPackage.kt

@@ -0,0 +1,32 @@
+package com.appexitlib
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+// TurboReactPackage works for both Old and New Architecture:
+// - Old arch: uses the standard module registry
+// - New arch: provides TurboModule instances via JSI
+class AppExitPackage : TurboReactPackage() {
+
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? =
+    if (name == AppExitModule.NAME) AppExitModule(reactContext) else null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+    mapOf(
+      AppExitModule.NAME to ReactModuleInfo(
+        _name = AppExitModule.NAME,
+        _className = AppExitModule.NAME,
+        _canOverrideExistingModule = false,
+        _needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED,
+      )
+    )
+  }
+}

package/android/src/newarch/java/com/appexitlib/NativeAppExitSpec.kt

@@ -0,0 +1,9 @@
+package com.appexitlib
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+// New Architecture: extends the codegen-generated TurboModule spec.
+// The codegen reads src/NativeAppExit.ts and produces RNAppExitSpec.
+// This class bridges our module to that generated spec.
+abstract class NativeAppExitSpec(context: ReactApplicationContext) :
+  com.appexitlib.NativeRNAppExitSpec(context)

package/android/src/oldarch/java/com/appexitlib/NativeAppExitSpec.kt

@@ -0,0 +1,14 @@
+package com.appexitlib
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+
+// Old Architecture: a plain ReactContextBaseJavaModule with the same abstract
+// interface so AppExitModule compiles identically in both architectures.
+abstract class NativeAppExitSpec(context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context) {
+
+  abstract fun exitApp()
+  abstract fun sendToBackground()
+  abstract override fun getConstants(): Map<String, Any>?
+}

package/ios/AppExit.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface AppExit : NSObject <RCTBridgeModule>
+
+@end

package/ios/AppExit.mm

@@ -0,0 +1,45 @@
+#import "AppExit.h"
+#import <UIKit/UIKit.h>
+
+@implementation AppExit
+
+RCT_EXPORT_MODULE(AppExit)
+
+// Expose compile-time constants to JS so callers can branch without platform checks.
+- (NSDictionary *)constantsToExport {
+  return @{
+    // iOS does not have a public OS-level background API, so we surface this as false.
+    // sendToBackground uses a best-effort private UIApplication selector that works
+    // on current iOS versions but is not App Store guaranteed.
+    @"isBackgroundSupported": @NO
+  };
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+// Terminate the process.
+// Apple's HIG recommends against calling exit() in App Store apps — iOS is designed
+// to handle app lifecycle automatically. Prefer sendToBackground() in production.
+// This exists for developer tooling, kiosks, or enterprise apps where hard exit is valid.
+RCT_EXPORT_METHOD(exitApp) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    exit(0);
+  });
+}
+
+// Suspend the app by sending it to the background.
+// Uses UIApplication's "suspend" selector, which is the same action triggered
+// when the user presses the Home button. This is not a documented public API,
+// but has been stable across iOS versions and doesn't risk App Store rejection
+// the same way exit() does.
+RCT_EXPORT_METHOD(sendToBackground) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    UIApplication *app = [UIApplication sharedApplication];
+    [app performSelector:@selector(suspend)];
+  });
+}
+
+
+@end

package/lib/commonjs/NativeAppExit.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('AppExit');
+//# sourceMappingURL=NativeAppExit.js.map

package/lib/commonjs/NativeAppExit.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeAppExit.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GA6BpCC,gCAAmB,CAACC,YAAY,CAAO,SAAS,CAAC","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.AppExit = void 0;
+var _reactNative = require("react-native");
+var _NativeAppExit = _interopRequireDefault(require("./NativeAppExit.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const constants = _NativeAppExit.default.getConstants();
+const AppExit = exports.AppExit = {
+  /**
+   * True on Android where moveTaskToBack is a first-class OS feature.
+   * False on iOS — Apple controls backgrounding; there is no public API.
+   */
+  isBackgroundSupported: constants.isBackgroundSupported,
+  /**
+   * Exit or background the app.
+   *
+   * @example
+   * // Hard exit
+   * AppExit.exit();
+   *
+   * @example
+   * // Send to background instead of killing
+   * AppExit.exit({ background: true });
+   */
+  exit(options = {}) {
+    if (options.background) {
+      AppExit.sendToBackground();
+    } else {
+      AppExit.exitApp();
+    }
+  },
+  /**
+   * Terminate the app process immediately.
+   *
+   * iOS warning: Apple guidelines discourage calling exit() from production
+   * apps distributed via the App Store. Prefer sendToBackground() on iOS.
+   */
+  exitApp() {
+    _NativeAppExit.default.exitApp();
+  },
+  /**
+   * Move the app to the background without terminating the process.
+   *
+   * Android: moveTaskToBack(true) — native and reliable.
+   * iOS: best-effort suspend via UIApplication private selector.
+   *      Not guaranteed to work across all iOS versions.
+   */
+  sendToBackground() {
+    if (_reactNative.Platform.OS === 'android' || _reactNative.Platform.OS === 'ios') {
+      _NativeAppExit.default.sendToBackground();
+    }
+  }
+};
+var _default = exports.default = AppExit;
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_NativeAppExit","_interopRequireDefault","e","__esModule","default","constants","NativeAppExit","getConstants","AppExit","exports","isBackgroundSupported","exit","options","background","sendToBackground","exitApp","Platform","OS","_default"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,cAAA,GAAAC,sBAAA,CAAAF,OAAA;AAA4C,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAW5C,MAAMG,SAAS,GAAGC,sBAAa,CAACC,YAAY,CAAC,CAAC;AAE9C,MAAMC,OAAO,GAAAC,OAAA,CAAAD,OAAA,GAAG;EACd;AACF;AACA;AACA;EACEE,qBAAqB,EAAEL,SAAS,CAACK,qBAAqB;EAEtD;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,IAAIA,CAACC,OAAuB,GAAG,CAAC,CAAC,EAAQ;IACvC,IAAIA,OAAO,CAACC,UAAU,EAAE;MACtBL,OAAO,CAACM,gBAAgB,CAAC,CAAC;IAC5B,CAAC,MAAM;MACLN,OAAO,CAACO,OAAO,CAAC,CAAC;IACnB;EACF,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;EACEA,OAAOA,CAAA,EAAS;IACdT,sBAAa,CAACS,OAAO,CAAC,CAAC;EACzB,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;EACED,gBAAgBA,CAAA,EAAS;IACvB,IAAIE,qBAAQ,CAACC,EAAE,KAAK,SAAS,IAAID,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACtDX,sBAAa,CAACQ,gBAAgB,CAAC,CAAC;IAClC;EACF;AACF,CAAC;AAAC,IAAAI,QAAA,GAAAT,OAAA,CAAAL,OAAA,GAGaI,OAAO","ignoreList":[]}

package/lib/module/NativeAppExit.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('AppExit');
+//# sourceMappingURL=NativeAppExit.js.map

package/lib/module/NativeAppExit.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeAppExit.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;AA6BlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,SAAS,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { Platform } from 'react-native';
+import NativeAppExit from "./NativeAppExit.js";
+const constants = NativeAppExit.getConstants();
+const AppExit = {
+  /**
+   * True on Android where moveTaskToBack is a first-class OS feature.
+   * False on iOS — Apple controls backgrounding; there is no public API.
+   */
+  isBackgroundSupported: constants.isBackgroundSupported,
+  /**
+   * Exit or background the app.
+   *
+   * @example
+   * // Hard exit
+   * AppExit.exit();
+   *
+   * @example
+   * // Send to background instead of killing
+   * AppExit.exit({ background: true });
+   */
+  exit(options = {}) {
+    if (options.background) {
+      AppExit.sendToBackground();
+    } else {
+      AppExit.exitApp();
+    }
+  },
+  /**
+   * Terminate the app process immediately.
+   *
+   * iOS warning: Apple guidelines discourage calling exit() from production
+   * apps distributed via the App Store. Prefer sendToBackground() on iOS.
+   */
+  exitApp() {
+    NativeAppExit.exitApp();
+  },
+  /**
+   * Move the app to the background without terminating the process.
+   *
+   * Android: moveTaskToBack(true) — native and reliable.
+   * iOS: best-effort suspend via UIApplication private selector.
+   *      Not guaranteed to work across all iOS versions.
+   */
+  sendToBackground() {
+    if (Platform.OS === 'android' || Platform.OS === 'ios') {
+      NativeAppExit.sendToBackground();
+    }
+  }
+};
+export { AppExit };
+export default AppExit;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Platform","NativeAppExit","constants","getConstants","AppExit","isBackgroundSupported","exit","options","background","sendToBackground","exitApp","OS"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,QAAQ,QAAQ,cAAc;AACvC,OAAOC,aAAa,MAAM,oBAAiB;AAW3C,MAAMC,SAAS,GAAGD,aAAa,CAACE,YAAY,CAAC,CAAC;AAE9C,MAAMC,OAAO,GAAG;EACd;AACF;AACA;AACA;EACEC,qBAAqB,EAAEH,SAAS,CAACG,qBAAqB;EAEtD;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,IAAIA,CAACC,OAAuB,GAAG,CAAC,CAAC,EAAQ;IACvC,IAAIA,OAAO,CAACC,UAAU,EAAE;MACtBJ,OAAO,CAACK,gBAAgB,CAAC,CAAC;IAC5B,CAAC,MAAM;MACLL,OAAO,CAACM,OAAO,CAAC,CAAC;IACnB;EACF,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;EACEA,OAAOA,CAAA,EAAS;IACdT,aAAa,CAACS,OAAO,CAAC,CAAC;EACzB,CAAC;EAED;AACF;AACA;AACA;AACA;AACA;AACA;EACED,gBAAgBA,CAAA,EAAS;IACvB,IAAIT,QAAQ,CAACW,EAAE,KAAK,SAAS,IAAIX,QAAQ,CAACW,EAAE,KAAK,KAAK,EAAE;MACtDV,aAAa,CAACQ,gBAAgB,CAAC,CAAC;IAClC;EACF;AACF,CAAC;AAED,SAASL,OAAO;AAChB,eAAeA,OAAO","ignoreList":[]}

package/lib/typescript/src/NativeAppExit.d.ts

@@ -0,0 +1,28 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    /**
+     * Terminates the application process.
+     * Android: kills the process via Process.killProcess.
+     * iOS: calls exit(0). Note: Apple discourages this — avoid calling on iOS
+     * if your app is on the App Store; prefer sendToBackground instead.
+     */
+    exitApp(): void;
+    /**
+     * Moves the app to the background without terminating the process.
+     * Android: moveTaskToBack(true) — fully supported.
+     * iOS: suspends the app via the UIApplication suspend selector — best effort.
+     */
+    sendToBackground(): void;
+    /**
+     * Returns compile-time constants about platform capabilities.
+     */
+    getConstants(): {
+        /**
+         * True on Android. iOS returns false because backgrounding is OS-controlled.
+         */
+        isBackgroundSupported: boolean;
+    };
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeAppExit.d.ts.map

package/lib/typescript/src/NativeAppExit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAppExit.d.ts","sourceRoot":"","sources":["../../../src/NativeAppExit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC;;;;;OAKG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;;OAIG;IACH,gBAAgB,IAAI,IAAI,CAAC;IAEzB;;OAEG;IACH,YAAY,IAAI;QACd;;WAEG;QACH,qBAAqB,EAAE,OAAO,CAAC;KAChC,CAAC;CACH;;AAED,wBAAiE"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,45 @@
+export type AppExitOptions = {
+    /**
+     * When true, moves the app to background instead of terminating.
+     * On iOS this suspends the app; on Android it calls moveTaskToBack.
+     * Defaults to false (full exit).
+     */
+    background?: boolean;
+};
+declare const AppExit: {
+    /**
+     * True on Android where moveTaskToBack is a first-class OS feature.
+     * False on iOS — Apple controls backgrounding; there is no public API.
+     */
+    isBackgroundSupported: boolean;
+    /**
+     * Exit or background the app.
+     *
+     * @example
+     * // Hard exit
+     * AppExit.exit();
+     *
+     * @example
+     * // Send to background instead of killing
+     * AppExit.exit({ background: true });
+     */
+    exit(options?: AppExitOptions): void;
+    /**
+     * Terminate the app process immediately.
+     *
+     * iOS warning: Apple guidelines discourage calling exit() from production
+     * apps distributed via the App Store. Prefer sendToBackground() on iOS.
+     */
+    exitApp(): void;
+    /**
+     * Move the app to the background without terminating the process.
+     *
+     * Android: moveTaskToBack(true) — native and reliable.
+     * iOS: best-effort suspend via UIApplication private selector.
+     *      Not guaranteed to work across all iOS versions.
+     */
+    sendToBackground(): void;
+};
+export { AppExit };
+export default AppExit;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAIF,QAAA,MAAM,OAAO;IACX;;;OAGG;;IAGH;;;;;;;;;;OAUG;mBACW,cAAc,GAAQ,IAAI;IAQxC;;;;;OAKG;eACQ,IAAI;IAIf;;;;;;OAMG;wBACiB,IAAI;CAKzB,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,CAAC;AACnB,eAAe,OAAO,CAAC"}

package/package.json

@@ -0,0 +1,121 @@
+{
+  "name": "rn-app-exit",
+  "version": "1.0.0",
+  "description": "Exit or background your React Native app — supports New Architecture (TurboModules) and Old Architecture with Kotlin/Swift native implementations.",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/src/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/module/index.js",
+      "require": "./lib/commonjs/index.js",
+      "types": "./lib/typescript/src/index.d.ts"
+    }
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "LICENSE",
+    "!ios/build",
+    "!android/build",
+    "!android/.gradle",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
+  "scripts": {
+    "build": "bob build",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "prepare": "bob build",
+    "test": "jest"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "exit",
+    "quit",
+    "android",
+    "exit-app",
+    "background",
+    "turbomodule",
+    "new-architecture"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pixelcube/rn-app-exit.git"
+  },
+  "author": "pixelcube",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pixelcube/rn-app-exit/issues"
+  },
+  "homepage": "https://github.com/pixelcube/rn-app-exit#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@react-native/babel-preset": "^0.76.0",
+    "@react-native/eslint-config": "^0.76.0",
+    "@types/jest": "^29.5.12",
+    "@types/react": "^18.2.6",
+    "eslint": "^8.51.0",
+    "jest": "^29.7.0",
+    "react": "18.3.1",
+    "react-native": "0.76.0",
+    "react-native-builder-bob": "^0.30.0",
+    "typescript": "^5.0.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "codegenConfig": {
+    "name": "RNAppExitSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.appexitlib"
+    }
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "commonjs",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  }
+}

package/rn-app-exit.podspec

@@ -0,0 +1,35 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "rn-app-exit"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => package["repository"]["url"], :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  # New Architecture (TurboModules)
+  if ENV["RCT_NEW_ARCH_ENABLED"] == "1"
+    s.compiler_flags = "-DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig = {
+      "DEFINES_MODULE" => "YES",
+      "SWIFT_COMPILATION_MODE" => "wholemodule"
+    }
+
+    s.dependency "React-RCTFabric"
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly"
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+  else
+    s.dependency "React-Core"
+  end
+end

package/src/NativeAppExit.ts

@@ -0,0 +1,31 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  /**
+   * Terminates the application process.
+   * Android: kills the process via Process.killProcess.
+   * iOS: calls exit(0). Note: Apple discourages this — avoid calling on iOS
+   * if your app is on the App Store; prefer sendToBackground instead.
+   */
+  exitApp(): void;
+
+  /**
+   * Moves the app to the background without terminating the process.
+   * Android: moveTaskToBack(true) — fully supported.
+   * iOS: suspends the app via the UIApplication suspend selector — best effort.
+   */
+  sendToBackground(): void;
+
+  /**
+   * Returns compile-time constants about platform capabilities.
+   */
+  getConstants(): {
+    /**
+     * True on Android. iOS returns false because backgrounding is OS-controlled.
+     */
+    isBackgroundSupported: boolean;
+  };
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('AppExit');

package/src/index.ts

@@ -0,0 +1,66 @@
+import { Platform } from 'react-native';
+import NativeAppExit from './NativeAppExit';
+
+export type AppExitOptions = {
+  /**
+   * When true, moves the app to background instead of terminating.
+   * On iOS this suspends the app; on Android it calls moveTaskToBack.
+   * Defaults to false (full exit).
+   */
+  background?: boolean;
+};
+
+const constants = NativeAppExit.getConstants();
+
+const AppExit = {
+  /**
+   * True on Android where moveTaskToBack is a first-class OS feature.
+   * False on iOS — Apple controls backgrounding; there is no public API.
+   */
+  isBackgroundSupported: constants.isBackgroundSupported,
+
+  /**
+   * Exit or background the app.
+   *
+   * @example
+   * // Hard exit
+   * AppExit.exit();
+   *
+   * @example
+   * // Send to background instead of killing
+   * AppExit.exit({ background: true });
+   */
+  exit(options: AppExitOptions = {}): void {
+    if (options.background) {
+      AppExit.sendToBackground();
+    } else {
+      AppExit.exitApp();
+    }
+  },
+
+  /**
+   * Terminate the app process immediately.
+   *
+   * iOS warning: Apple guidelines discourage calling exit() from production
+   * apps distributed via the App Store. Prefer sendToBackground() on iOS.
+   */
+  exitApp(): void {
+    NativeAppExit.exitApp();
+  },
+
+  /**
+   * Move the app to the background without terminating the process.
+   *
+   * Android: moveTaskToBack(true) — native and reliable.
+   * iOS: best-effort suspend via UIApplication private selector.
+   *      Not guaranteed to work across all iOS versions.
+   */
+  sendToBackground(): void {
+    if (Platform.OS === 'android' || Platform.OS === 'ios') {
+      NativeAppExit.sendToBackground();
+    }
+  },
+};
+
+export { AppExit };
+export default AppExit;