@matiks/rn-app-state 1.0.0

package/nitrogen/generated/ios/swift/Func_void_AppStateChangeEvent.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_AppStateChangeEvent.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ event: AppStateChangeEvent) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_AppStateChangeEvent {
+  public typealias bridge = margelo.nitro.appstate.bridge.swift
+
+  private let closure: (_ event: AppStateChangeEvent) -> Void
+
+  public init(_ closure: @escaping (_ event: AppStateChangeEvent) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(event: AppStateChangeEvent) -> Void {
+    self.closure(event)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_AppStateChangeEvent`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_AppStateChangeEvent>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_AppStateChangeEvent {
+    return Unmanaged<Func_void_AppStateChangeEvent>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridAppStateModuleSpec.swift

@@ -0,0 +1,57 @@
+///
+/// HybridAppStateModuleSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// See ``HybridAppStateModuleSpec``
+public protocol HybridAppStateModuleSpec_protocol: HybridObject {
+  // Properties
+  var wasKilledLastSession: Bool { get }
+
+  // Methods
+  func getCurrentState() throws -> String
+  func addListener(onStateChange: @escaping (_ event: AppStateChangeEvent) -> Void) throws -> AppStateListener
+  func getStateOnNotification() throws -> String
+}
+
+public extension HybridAppStateModuleSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject AppStateModule]"
+  }
+}
+
+/// See ``HybridAppStateModuleSpec``
+open class HybridAppStateModuleSpec_base {
+  private weak var cxxWrapper: HybridAppStateModuleSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridAppStateModuleSpec_cxx {
+  #if DEBUG
+    guard self is any HybridAppStateModuleSpec else {
+      fatalError("`self` is not a `HybridAppStateModuleSpec`! Did you accidentally inherit from `HybridAppStateModuleSpec_base` instead of `HybridAppStateModuleSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridAppStateModuleSpec_cxx(self as! any HybridAppStateModuleSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the AppStateModule HybridObject.
+ * Implement this protocol to create Swift-based instances of AppStateModule.
+ * ```swift
+ * class HybridAppStateModule : HybridAppStateModuleSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridAppStateModuleSpec = HybridAppStateModuleSpec_protocol & HybridAppStateModuleSpec_base

package/nitrogen/generated/ios/swift/HybridAppStateModuleSpec_cxx.swift

@@ -0,0 +1,172 @@
+///
+/// HybridAppStateModuleSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridAppStateModuleSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridAppStateModuleSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::appstate::bridge::swift`)
+   * from `NitroAppState-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.appstate.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridAppStateModuleSpec` Swift protocol.
+   */
+  private var __implementation: any HybridAppStateModuleSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridAppStateModuleSpec_
+
+  /**
+   * Create a new `HybridAppStateModuleSpec_cxx` that wraps the given `HybridAppStateModuleSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridAppStateModuleSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridAppStateModuleSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridAppStateModuleSpec() -> any HybridAppStateModuleSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridAppStateModuleSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridAppStateModuleSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridAppStateModuleSpec_cxx {
+    return Unmanaged<HybridAppStateModuleSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridAppStateModuleSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridAppStateModuleSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridAppStateModuleSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridAppStateModuleSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridAppStateModuleSpec_cxx) -> Bool {
+    return self.__implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  public final var wasKilledLastSession: Bool {
+    @inline(__always)
+    get {
+      return self.__implementation.wasKilledLastSession
+    }
+  }
+
+  // Methods
+  @inline(__always)
+  public final func getCurrentState() -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.getCurrentState()
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func addListener(onStateChange: bridge.Func_void_AppStateChangeEvent) -> bridge.Result_AppStateListener_ {
+    do {
+      let __result = try self.__implementation.addListener(onStateChange: { () -> (AppStateChangeEvent) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_AppStateChangeEvent(onStateChange)
+        return { (__event: AppStateChangeEvent) -> Void in
+          __wrappedFunction.call(__event)
+        }
+      }())
+      let __resultCpp = __result
+      return bridge.create_Result_AppStateListener_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_AppStateListener_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getStateOnNotification() -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.getStateOnNotification()
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
+    }
+  }
+}

package/nitrogen/generated/shared/c++/AppStateChangeEvent.hpp

@@ -0,0 +1,83 @@
+///
+/// AppStateChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::appstate {
+
+  /**
+   * A struct which can be represented as a JavaScript object (AppStateChangeEvent).
+   */
+  struct AppStateChangeEvent final {
+  public:
+    std::string state     SWIFT_PRIVATE;
+
+  public:
+    AppStateChangeEvent() = default;
+    explicit AppStateChangeEvent(std::string state): state(state) {}
+
+  public:
+    friend bool operator==(const AppStateChangeEvent& lhs, const AppStateChangeEvent& rhs) = default;
+  };
+
+} // namespace margelo::nitro::appstate
+
+namespace margelo::nitro {
+
+  // C++ AppStateChangeEvent <> JS AppStateChangeEvent (object)
+  template <>
+  struct JSIConverter<margelo::nitro::appstate::AppStateChangeEvent> final {
+    static inline margelo::nitro::appstate::AppStateChangeEvent fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::appstate::AppStateChangeEvent(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "state")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::appstate::AppStateChangeEvent& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "state"), JSIConverter<std::string>::toJSI(runtime, arg.state));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "state")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/AppStateListener.hpp

@@ -0,0 +1,83 @@
+///
+/// AppStateListener.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <functional>
+
+namespace margelo::nitro::appstate {
+
+  /**
+   * A struct which can be represented as a JavaScript object (AppStateListener).
+   */
+  struct AppStateListener final {
+  public:
+    std::function<void()> remove     SWIFT_PRIVATE;
+
+  public:
+    AppStateListener() = default;
+    explicit AppStateListener(std::function<void()> remove): remove(remove) {}
+
+  public:
+    // AppStateListener is not equatable because these properties are not equatable: remove
+  };
+
+} // namespace margelo::nitro::appstate
+
+namespace margelo::nitro {
+
+  // C++ AppStateListener <> JS AppStateListener (object)
+  template <>
+  struct JSIConverter<margelo::nitro::appstate::AppStateListener> final {
+    static inline margelo::nitro::appstate::AppStateListener fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::appstate::AppStateListener(
+        JSIConverter<std::function<void()>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remove")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::appstate::AppStateListener& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "remove"), JSIConverter<std::function<void()>>::toJSI(runtime, arg.remove));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::function<void()>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remove")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridAppStateModuleSpec.cpp

@@ -0,0 +1,24 @@
+///
+/// HybridAppStateModuleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAppStateModuleSpec.hpp"
+
+namespace margelo::nitro::appstate {
+
+  void HybridAppStateModuleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("wasKilledLastSession", &HybridAppStateModuleSpec::getWasKilledLastSession);
+      prototype.registerHybridMethod("getCurrentState", &HybridAppStateModuleSpec::getCurrentState);
+      prototype.registerHybridMethod("addListener", &HybridAppStateModuleSpec::addListener);
+      prototype.registerHybridMethod("getStateOnNotification", &HybridAppStateModuleSpec::getStateOnNotification);
+    });
+  }
+
+} // namespace margelo::nitro::appstate

package/nitrogen/generated/shared/c++/HybridAppStateModuleSpec.hpp

@@ -0,0 +1,70 @@
+///
+/// HybridAppStateModuleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `AppStateListener` to properly resolve imports.
+namespace margelo::nitro::appstate { struct AppStateListener; }
+// Forward declaration of `AppStateChangeEvent` to properly resolve imports.
+namespace margelo::nitro::appstate { struct AppStateChangeEvent; }
+
+#include <string>
+#include "AppStateListener.hpp"
+#include "AppStateChangeEvent.hpp"
+#include <functional>
+
+namespace margelo::nitro::appstate {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AppStateModule`
+   * Inherit this class to create instances of `HybridAppStateModuleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAppStateModule: public HybridAppStateModuleSpec {
+   * public:
+   *   HybridAppStateModule(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAppStateModuleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAppStateModuleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAppStateModuleSpec() override = default;
+
+    public:
+      // Properties
+      virtual bool getWasKilledLastSession() = 0;
+
+    public:
+      // Methods
+      virtual std::string getCurrentState() = 0;
+      virtual AppStateListener addListener(const std::function<void(const AppStateChangeEvent& /* event */)>& onStateChange) = 0;
+      virtual std::string getStateOnNotification() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AppStateModule";
+  };
+
+} // namespace margelo::nitro::appstate

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@matiks/rn-app-state",
+  "version": "1.0.0",
+  "description": "Nitro-powered native app state module for React Native",
+  "main": "lib/index",
+  "module": "lib/index",
+  "types": "lib/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "files": [
+    "src",
+    "lib",
+    "nitrogen",
+    "android/build.gradle",
+    "android/gradle.properties",
+    "android/fix-prefab.gradle",
+    "android/CMakeLists.txt",
+    "android/src",
+    "ios/**/*.swift",
+    "ios/**/*.m",
+    "ios/**/*.mm",
+    "cpp/**/*.{hpp,cpp}",
+    "nitro.json",
+    "*.podspec",
+    "README.md",
+    "FLOW.md"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf android/build lib",
+    "specs": "npx nitrogen@0.33.9 --logLevel=\"debug\""
+  },
+  "keywords": [
+    "react-native",
+    "nitro",
+    "app-state",
+    "lifecycle"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/matiks-com/rn-app-state.git"
+  },
+  "author": "Matiks",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/matiks-com/rn-app-state/issues"
+  },
+  "homepage": "https://github.com/matiks-com/rn-app-state#readme",
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-nitro-modules": "*"
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { useNitroAppState } from './useNitroAppState'
+export type { AppStateType, NitroAppStateResult } from './useNitroAppState'

package/src/specs/AppState.nitro.ts

@@ -0,0 +1,57 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+/**
+ * Event payload for app state change notifications.
+ * Nitro requires event payloads to be non-empty interfaces.
+ */
+export interface AppStateChangeEvent {
+  state: string;
+}
+
+/**
+ * Listener handle returned by addListener.
+ * Call remove() to unsubscribe.
+ */
+export interface AppStateListener {
+  remove: () => void;
+}
+
+/**
+ * HybridObject spec for the native AppState module.
+ *
+ * Provides synchronous access to the current app lifecycle state
+ * and a listener-based API for state change notifications.
+ * Works on both iOS (Swift) and Android (Kotlin).
+ */
+export interface AppStateModule
+  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
+  /**
+   * Get the current app state synchronously.
+   * Returns 'active' or 'background'.
+   */
+  getCurrentState(): string;
+
+  /**
+   * Whether the app was killed/terminated in the previous session.
+   * This is determined on cold start by checking if the previous
+   * session ended cleanly (via a persisted flag).
+   */
+  readonly wasKilledLastSession: boolean;
+
+  /**
+   * Register a listener for app state changes.
+   * The callback receives the new state as a string ('active' | 'background').
+   * Returns a Listener with a remove() method to unsubscribe.
+   */
+  addListener(
+    onStateChange: (event: AppStateChangeEvent) => void,
+  ): AppStateListener;
+
+  /**
+   * Called from JS/native when a push notification is received.
+   * Returns the current app state at the moment of the call.
+   * Useful for knowing if a notification arrived while app was
+   * in foreground or background.
+   */
+  getStateOnNotification(): string;
+}

package/src/useNitroAppState/index.ts

@@ -0,0 +1,2 @@
+export { useNitroAppState } from './useNitroAppState'
+export type { AppStateType, NitroAppStateResult } from './types'

package/src/useNitroAppState/types.ts

@@ -0,0 +1,21 @@
+/**
+ * The possible app lifecycle states.
+ *
+ * - `active`: App is in the foreground and interactive
+ * - `background`: App is in the background (or inactive on iOS)
+ * - `killed`: App was terminated/killed in the previous session
+ *   (only reported briefly on cold start before transitioning to `active`)
+ */
+export type AppStateType = 'active' | 'background' | 'killed'
+
+/**
+ * Return type for the useNitroAppState hook.
+ */
+export interface NitroAppStateResult {
+  /** Current app lifecycle state. Reactive -- triggers re-renders on change. */
+  appState: AppStateType
+  /** Whether the app was killed/terminated in the previous session. */
+  wasKilledLastSession: boolean
+  /** Get the current state at the moment of a notification receipt. */
+  getStateOnNotification: () => AppStateType
+}