@onekeyfe/react-native-perf-stats 3.0.35 → 3.0.36

package/lib/typescript/src/ReactNativePerfStats.nitro.d.ts

@@ -12,18 +12,53 @@ export interface PerfSample {
     /**
      * UI thread frame rate, frames per second over the last 1 s window.
      * Measured on the platform's main thread via Choreographer (Android)
-     * or CADisplayLink (iOS). `0` until at least one window has elapsed.
+     * or CADisplayLink (iOS). `0` until at least one window has elapsed
+     * **and the sampler is running** — the underlying frame monitor only
+     * runs between `start()` and `stop()`, so one-shot `sample()` calls
+     * issued outside that window always report `0` here.
      */
     uiFps: number;
     /**
      * JS thread frame rate, frames per second reported by the JS-side
      * `requestAnimationFrame` ticker (see `startJsFpsTracker`). `0` if
      * the tracker has not been started or no hint has been received yet.
+     * Same caveat as `uiFps`: one-shot `sample()` calls issued before
+     * `start()` (or after `stop()`) report `0` here.
      */
     jsFps: number;
     /** Wall-clock timestamp (ms since unix epoch) when the sample was taken. */
     timestamp: number;
 }
+/**
+ * Severity of a system-emitted memory pressure event, normalised across
+ * platforms.
+ *
+ * - `low`: Android `TRIM_MEMORY_RUNNING_MODERATE` /
+ *   `TRIM_MEMORY_RUNNING_LOW`. iOS does not emit this level (iOS only
+ *   fires the critical warning), so JS code should treat the absence of
+ *   `low` events on iOS as expected, not a missing signal.
+ * - `critical`: iOS `UIApplicationDidReceiveMemoryWarningNotification`;
+ *   Android `TRIM_MEMORY_RUNNING_CRITICAL` or `onLowMemory()`. Indicates
+ *   the OS is about to start killing background apps (Android) or the
+ *   app itself (iOS jetsam). Subscribers should drop everything that
+ *   can be rebuilt on demand.
+ */
+export type MemoryWarningLevel = 'low' | 'critical';
+export interface MemoryWarningEvent {
+    level: MemoryWarningLevel;
+    /**
+     * Process RSS in bytes at the moment the warning fired. `0` if the
+     * lookup failed.
+     *
+     * On iOS the primary source is `phys_footprint`; if that fails, the
+     * fallback path reads `resident_size`, which is semantically smaller
+     * and noisier. The two values are not directly comparable, so treat
+     * unexpected magnitude differences across reports cautiously.
+     */
+    rss: number;
+    /** Wall-clock timestamp (ms since unix epoch). */
+    timestamp: number;
+}
 export interface ReactNativePerfStats extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
@@ -73,5 +108,78 @@ export interface ReactNativePerfStats extends HybridObject<{
      * than calling this directly.
      */
     setJsFpsHint(fps: number): void;
+    /**
+     * Subscribe to OS-emitted memory pressure events.
+     *
+     * - iOS: `UIApplicationDidReceiveMemoryWarningNotification`, mapped to
+     *   `critical`. Fires on the main thread.
+     * - Android: `ComponentCallbacks2.onTrimMemory` filtered to
+     *   `TRIM_MEMORY_RUNNING_*` (foreground process pressure), plus
+     *   `onLowMemory()` as `critical`. Fires on the main thread.
+     *
+     * The native listener is registered process-wide on first call and
+     * survives `stop()` — memory pressure is independent of the perf
+     * sampler being active. Callbacks are invoked on the JS thread.
+     *
+     * **Always pair this with `removeMemoryWarningListener`** (e.g. in a
+     * React effect cleanup): the callback closure is retained for the life
+     * of the subscription, and forgetting to remove leaks every object the
+     * closure transitively captures — typically the React component instance
+     * that registered it. This matters in dev too: the native listener
+     * table is a process-wide singleton that **does not clear on RN
+     * reload**, so a Fast-Refresh / dev reload that drops the JS realm
+     * without first calling `removeMemoryWarningListener` will leave the
+     * pre-reload callback in the table, pointing at a dead JS context.
+     * The cleanest fix is the same effect-cleanup pattern.
+     *
+     * The relative order in which subscribed callbacks fire for a single
+     * event is **not guaranteed** — iOS iterates a hash dictionary, Android
+     * iterates a LinkedHashMap, and either may change. Don't take a
+     * cross-listener dependency.
+     *
+     * Dispatch: when a warning arrives, the native module walks all
+     * registered callbacks **serially on the main thread** before each
+     * one hops to the JS thread. Cost scales with the number of
+     * subscribers — keep N small (single-digit) and avoid registering one
+     * listener per render-tree branch.
+     *
+     * Side effects of the warning itself (before your callback fires):
+     * - **iOS** runs the same reclaim path as `cleanupNativeCaches`,
+     *   which drops the process-wide `URLCache.shared`, the WK HTTP /
+     *   AppCache / Service-Worker stores, and triggers a libmalloc
+     *   pressure relief. If any code path in the app depends on
+     *   URLCache for offline HTTP content, or on a Service Worker for
+     *   offline WebView fallback, that state is dropped here — don't
+     *   register this listener if either is load-bearing.
+     * - **Android** runs `Runtime.gc()` on every warning (LOW and
+     *   CRITICAL). ART treats it as a hint.
+     *
+     * Returns an opaque id; pass it to `removeMemoryWarningListener` to
+     * unsubscribe.
+     */
+    addMemoryWarningListener(callback: (event: MemoryWarningEvent) => void): number;
+    /** Unsubscribe a previously-registered memory warning listener. No-op for unknown ids. */
+    removeMemoryWarningListener(id: number): void;
+    /**
+     * Trigger the same native reclaim path the OS memory-warning observer
+     * runs, on demand. Use when the JS layer has reason to believe pressure
+     * is building before the OS posts a warning (e.g. backgrounding, a
+     * heavy route transition, jotai cache invalidation, post-import).
+     *
+     * - **iOS** clears `URLCache.shared` (process-wide HTTP response cache;
+     *   any consumer that relies on URLCache for offline content loses
+     *   it until the next request) and the WK HTTP / AppCache / Service-
+     *   Worker stores (auth-related cookies / localStorage / IndexedDB
+     *   are preserved). Then dispatches `malloc_zone_pressure_relief` on
+     *   a background queue — the call returns to JS immediately, but the
+     *   zone walk that actually frees pages can take 100-500 ms.
+     * - **Android** asks ART to GC via `Runtime.gc()` (hint only; the
+     *   runtime decides whether to honour it). Returns quickly.
+     *
+     * Cheap on Android, cheap-to-return on iOS (heavy work runs async).
+     * Pair with `forceGarbageCollection()` if you also want the JS engine
+     * to participate.
+     */
+    cleanupNativeCaches(): void;
 }
 //# sourceMappingURL=ReactNativePerfStats.nitro.d.ts.map

package/lib/typescript/src/ReactNativePerfStats.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactNativePerfStats.nitro.d.ts","sourceRoot":"","sources":["../../../src/ReactNativePerfStats.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD;;;;;;;;OAQG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhC,+EAA+E;IAC/E,IAAI,IAAI,IAAI,CAAC;IAEb;;;;;;;;;;;;;OAaG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB,gFAAgF;IAChF,WAAW,IAAI,IAAI,CAAC;IAEpB;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAE9B;;;;;;;;OAQG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC"}
+{"version":3,"file":"ReactNativePerfStats.nitro.d.ts","sourceRoot":"","sources":["../../../src/ReactNativePerfStats.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;;;OAOG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,UAAU,CAAC;AAEpD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,kBAAkB,CAAC;IAC1B;;;;;;;;OAQG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD;;;;;;;;OAQG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhC,+EAA+E;IAC/E,IAAI,IAAI,IAAI,CAAC;IAEb;;;;;;;;;;;;;OAaG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB,gFAAgF;IAChF,WAAW,IAAI,IAAI,CAAC;IAEpB;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAE9B;;;;;;;;OAQG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,wBAAwB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,MAAM,CAAC;IAEhF,0FAA0F;IAC1F,2BAA2B,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAE9C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBAAmB,IAAI,IAAI,CAAC;CAC7B"}

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

@@ -1,3 +1,4 @@
+import type { MemoryWarningEvent } from './ReactNativePerfStats.nitro';
 export type * from './ReactNativePerfStats.nitro';
 /**
  * Start the JS-side FPS ticker. Normally invoked automatically by
@@ -19,5 +20,35 @@ export declare const ReactNativePerfStats: {
     hideOverlay: () => void;
     sample: () => Promise<import("./ReactNativePerfStats.nitro").PerfSample>;
     setJsFpsHint: (fps: number) => void;
+    addMemoryWarningListener: (callback: (event: MemoryWarningEvent) => void) => number;
+    removeMemoryWarningListener: (id: number) => void;
+    /**
+     * Run the same native reclaim path the OS memory-warning observer
+     * triggers, on demand. Returns immediately (heavy work runs async
+     * on iOS). See the spec doc for what gets dropped on each platform.
+     */
+    cleanupNativeCaches: () => void;
+    /**
+     * Best-effort hint to the JS engine that now is a good time to GC.
+     *
+     * Hermes does not expose a public `collectGarbage` binding in production
+     * builds; the only stable JS-level entry point is the (undocumented)
+     * `HermesInternal.gc` property, which is present in some builds and
+     * absent in others. We feature-detect it and fall back to a no-op so
+     * callers never have to branch.
+     *
+     * Returns `true` only if a GC binding was both found AND invoked
+     * without throwing. A `false` return therefore covers three cases —
+     * binding missing (production Hermes is the common case), binding
+     * present but threw, and any unexpected failure. The first miss is
+     * logged once via `console.warn` so the caller knows it landed in the
+     * "no binding" branch; throws are logged on every occurrence because
+     * those are real errors.
+     *
+     * Cost: when honoured, Hermes does a stop-the-world collection that
+     * can take 100–500 ms — never call this on the hot path. Memory-warning
+     * handlers are the intended use case.
+     */
+    forceGarbageCollection(): boolean;
 };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAMA,mBAAmB,8BAA8B,CAAC;AAwBlD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,gBAAgB,GAAE,MAAa,GAAG,IAAI,CAgBvE;AAED,+CAA+C;AAC/C,wBAAgB,gBAAgB,IAAI,IAAI,CAWvC;AAQD,eAAO,MAAM,oBAAoB;sBACb,MAAM,GAAG,IAAI;YAIvB,IAAI;uBAIK,IAAI;uBACJ,IAAI;;wBAED,MAAM,KAAG,IAAI;CAClC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,kBAAkB,EAEnB,MAAM,8BAA8B,CAAC;AAKtC,mBAAmB,8BAA8B,CAAC;AA6BlD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,gBAAgB,GAAE,MAAa,GAAG,IAAI,CAwBvE;AAED,+CAA+C;AAC/C,wBAAgB,gBAAgB,IAAI,IAAI,CAWvC;AAQD,eAAO,MAAM,oBAAoB;sBACb,MAAM,GAAG,IAAI;YAIvB,IAAI;uBAIK,IAAI;uBACJ,IAAI;;wBAED,MAAM,KAAG,IAAI;yCAIrB,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,KAC5C,MAAM;sCACyB,MAAM,KAAG,IAAI;IAE/C;;;;OAIG;+BACsB,IAAI;IAE7B;;;;;;;;;;;;;;;;;;;;OAoBG;8BACuB,OAAO;CAkClC,CAAC"}

package/nitrogen/generated/android/c++/JFunc_void_MemoryWarningEvent.hpp

@@ -0,0 +1,79 @@
+///
+/// JFunc_void_MemoryWarningEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "MemoryWarningEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JMemoryWarningEvent.hpp"
+#include "MemoryWarningLevel.hpp"
+#include "JMemoryWarningLevel.hpp"
+
+namespace margelo::nitro::reactnativeperfstats {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: MemoryWarningEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_MemoryWarningEvent: public jni::JavaClass<JFunc_void_MemoryWarningEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeperfstats/Func_void_MemoryWarningEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_MemoryWarningEvent` instance holds through JNI.
+     */
+    void invoke(const MemoryWarningEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JMemoryWarningEvent> /* event */)>("invoke");
+      method(self(), JMemoryWarningEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_MemoryWarningEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_MemoryWarningEvent_cxx final: public jni::HybridClass<JFunc_void_MemoryWarningEvent_cxx, JFunc_void_MemoryWarningEvent> {
+  public:
+    static jni::local_ref<JFunc_void_MemoryWarningEvent::javaobject> fromCpp(const std::function<void(const MemoryWarningEvent& /* event */)>& func) {
+      return JFunc_void_MemoryWarningEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_MemoryWarningEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JMemoryWarningEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const MemoryWarningEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeperfstats/Func_void_MemoryWarningEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_MemoryWarningEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_MemoryWarningEvent_cxx(const std::function<void(const MemoryWarningEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const MemoryWarningEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::reactnativeperfstats

package/nitrogen/generated/android/c++/JHybridReactNativePerfStatsSpec.cpp

@@ -9,11 +9,22 @@
 
 // Forward declaration of `PerfSample` to properly resolve imports.
 namespace margelo::nitro::reactnativeperfstats { struct PerfSample; }
+// Forward declaration of `MemoryWarningEvent` to properly resolve imports.
+namespace margelo::nitro::reactnativeperfstats { struct MemoryWarningEvent; }
+// Forward declaration of `MemoryWarningLevel` to properly resolve imports.
+namespace margelo::nitro::reactnativeperfstats { enum class MemoryWarningLevel; }
 
 #include "PerfSample.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "JPerfSample.hpp"
+#include "MemoryWarningEvent.hpp"
+#include <functional>
+#include "JFunc_void_MemoryWarningEvent.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JMemoryWarningEvent.hpp"
+#include "MemoryWarningLevel.hpp"
+#include "JMemoryWarningLevel.hpp"
 
 namespace margelo::nitro::reactnativeperfstats {
 
@@ -83,5 +94,18 @@ namespace margelo::nitro::reactnativeperfstats {
     static const auto method = javaClassStatic()->getMethod<void(double /* fps */)>("setJsFpsHint");
     method(_javaPart, fps);
   }
+  double JHybridReactNativePerfStatsSpec::addMemoryWarningListener(const std::function<void(const MemoryWarningEvent& /* event */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_MemoryWarningEvent::javaobject> /* callback */)>("addMemoryWarningListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_MemoryWarningEvent_cxx::fromCpp(callback));
+    return __result;
+  }
+  void JHybridReactNativePerfStatsSpec::removeMemoryWarningListener(double id) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* id */)>("removeMemoryWarningListener");
+    method(_javaPart, id);
+  }
+  void JHybridReactNativePerfStatsSpec::cleanupNativeCaches() {
+    static const auto method = javaClassStatic()->getMethod<void()>("cleanupNativeCaches");
+    method(_javaPart);
+  }
 
 } // namespace margelo::nitro::reactnativeperfstats

package/nitrogen/generated/android/c++/JHybridReactNativePerfStatsSpec.hpp

@@ -60,6 +60,9 @@ namespace margelo::nitro::reactnativeperfstats {
     void hideOverlay() override;
     std::shared_ptr<Promise<PerfSample>> sample() override;
     void setJsFpsHint(double fps) override;
+    double addMemoryWarningListener(const std::function<void(const MemoryWarningEvent& /* event */)>& callback) override;
+    void removeMemoryWarningListener(double id) override;
+    void cleanupNativeCaches() override;
 
   private:
     friend HybridBase;

package/nitrogen/generated/android/c++/JMemoryWarningEvent.hpp

@@ -0,0 +1,66 @@
+///
+/// JMemoryWarningEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MemoryWarningEvent.hpp"
+
+#include "JMemoryWarningLevel.hpp"
+#include "MemoryWarningLevel.hpp"
+
+namespace margelo::nitro::reactnativeperfstats {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MemoryWarningEvent" and the the Kotlin data class "MemoryWarningEvent".
+   */
+  struct JMemoryWarningEvent final: public jni::JavaClass<JMemoryWarningEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeperfstats/MemoryWarningEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MemoryWarningEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MemoryWarningEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLevel = clazz->getField<JMemoryWarningLevel>("level");
+      jni::local_ref<JMemoryWarningLevel> level = this->getFieldValue(fieldLevel);
+      static const auto fieldRss = clazz->getField<double>("rss");
+      double rss = this->getFieldValue(fieldRss);
+      static const auto fieldTimestamp = clazz->getField<double>("timestamp");
+      double timestamp = this->getFieldValue(fieldTimestamp);
+      return MemoryWarningEvent(
+        level->toCpp(),
+        rss,
+        timestamp
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMemoryWarningEvent::javaobject> fromCpp(const MemoryWarningEvent& value) {
+      using JSignature = JMemoryWarningEvent(jni::alias_ref<JMemoryWarningLevel>, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JMemoryWarningLevel::fromCpp(value.level),
+        value.rss,
+        value.timestamp
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativeperfstats

package/nitrogen/generated/android/c++/JMemoryWarningLevel.hpp

@@ -0,0 +1,59 @@
+///
+/// JMemoryWarningLevel.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MemoryWarningLevel.hpp"
+
+namespace margelo::nitro::reactnativeperfstats {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "MemoryWarningLevel" and the the Kotlin enum "MemoryWarningLevel".
+   */
+  struct JMemoryWarningLevel final: public jni::JavaClass<JMemoryWarningLevel> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeperfstats/MemoryWarningLevel;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum MemoryWarningLevel.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MemoryWarningLevel toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<MemoryWarningLevel>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JMemoryWarningLevel> fromCpp(MemoryWarningLevel value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLOW = clazz->getStaticField<JMemoryWarningLevel>("LOW");
+      static const auto fieldCRITICAL = clazz->getStaticField<JMemoryWarningLevel>("CRITICAL");
+      
+      switch (value) {
+        case MemoryWarningLevel::LOW:
+          return clazz->getStaticFieldValue(fieldLOW);
+        case MemoryWarningLevel::CRITICAL:
+          return clazz->getStaticFieldValue(fieldCRITICAL);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::reactnativeperfstats

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativeperfstats/Func_void_MemoryWarningEvent.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_MemoryWarningEvent.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativeperfstats
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(event: struct) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_MemoryWarningEvent: (MemoryWarningEvent) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(event: MemoryWarningEvent): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(event: struct) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_MemoryWarningEvent_cxx: Func_void_MemoryWarningEvent {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(event: MemoryWarningEvent): Unit
+    = invoke_cxx(event)
+
+  @FastNative
+  private external fun invoke_cxx(event: MemoryWarningEvent): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(event: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(MemoryWarningEvent) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_MemoryWarningEvent_java(private val function: (MemoryWarningEvent) -> Unit): Func_void_MemoryWarningEvent {
+  @DoNotStrip
+  @Keep
+  override fun invoke(event: MemoryWarningEvent): Unit {
+    return this.function(event)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativeperfstats/HybridReactNativePerfStatsSpec.kt

@@ -69,6 +69,23 @@ abstract class HybridReactNativePerfStatsSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun setJsFpsHint(fps: Double): Unit
+  
+  abstract fun addMemoryWarningListener(callback: (event: MemoryWarningEvent) -> Unit): Double
+  
+  @DoNotStrip
+  @Keep
+  private fun addMemoryWarningListener_cxx(callback: Func_void_MemoryWarningEvent): Double {
+    val __result = addMemoryWarningListener(callback)
+    return __result
+  }
+  
+  @DoNotStrip
+  @Keep
+  abstract fun removeMemoryWarningListener(id: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun cleanupNativeCaches(): Unit
 
   private external fun initHybrid(): HybridData
 

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativeperfstats/MemoryWarningEvent.kt

@@ -0,0 +1,44 @@
+///
+/// MemoryWarningEvent.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativeperfstats
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "MemoryWarningEvent".
+ */
+@DoNotStrip
+@Keep
+data class MemoryWarningEvent(
+  @DoNotStrip
+  @Keep
+  val level: MemoryWarningLevel,
+  @DoNotStrip
+  @Keep
+  val rss: Double,
+  @DoNotStrip
+  @Keep
+  val timestamp: Double
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(level: MemoryWarningLevel, rss: Double, timestamp: Double): MemoryWarningEvent {
+      return MemoryWarningEvent(level, rss, timestamp)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativeperfstats/MemoryWarningLevel.kt

@@ -0,0 +1,21 @@
+///
+/// MemoryWarningLevel.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativeperfstats
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "MemoryWarningLevel".
+ */
+@DoNotStrip
+@Keep
+enum class MemoryWarningLevel(@DoNotStrip @Keep val value: Int) {
+  LOW(0),
+  CRITICAL(1);
+}

package/nitrogen/generated/android/reactnativeperfstatsOnLoad.cpp

@@ -16,6 +16,7 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridReactNativePerfStatsSpec.hpp"
+#include "JFunc_void_MemoryWarningEvent.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::reactnativeperfstats {
@@ -28,6 +29,7 @@ int initialize(JavaVM* vm) {
   return facebook::jni::initialize(vm, [] {
     // Register native JNI methods
     margelo::nitro::reactnativeperfstats::JHybridReactNativePerfStatsSpec::registerNatives();
+    margelo::nitro::reactnativeperfstats::JFunc_void_MemoryWarningEvent_cxx::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(

package/nitrogen/generated/ios/ReactNativePerfStats-Swift-Cxx-Bridge.cpp

@@ -30,6 +30,14 @@ namespace margelo::nitro::reactnativeperfstats::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const MemoryWarningEvent& /* event */)>
+  Func_void_MemoryWarningEvent create_Func_void_MemoryWarningEvent(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativePerfStats::Func_void_MemoryWarningEvent::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const MemoryWarningEvent& event) mutable -> void {
+      swiftClosure.call(event);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridReactNativePerfStatsSpec>
   std::shared_ptr<HybridReactNativePerfStatsSpec> create_std__shared_ptr_HybridReactNativePerfStatsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativePerfStats::HybridReactNativePerfStatsSpec_cxx swiftPart = ReactNativePerfStats::HybridReactNativePerfStatsSpec_cxx::fromUnsafe(swiftUnsafePointer);