react-native-mmkv 4.1.2 → 4.3.0

package/lib/specs/MMKVFactory.nitro.d.ts

@@ -6,6 +6,12 @@ import type { MMKV } from './MMKV.nitro';
  * - `multi-process`: The MMKV instance may be used from multiple processes, such as app clips, share extensions or background services.
  */
 export type Mode = 'single-process' | 'multi-process';
+/**
+ * Configures the encryption algorithm for the MMKV instance.
+ * - `AES-128`: Uses AES-128 encryption (default).
+ * - `AES-256`: Uses AES-256 encryption for enhanced security.
+ */
+export type EncryptionType = 'AES-128' | 'AES-256';
 /**
  * Used for configuration of a single MMKV instance.
  */
@@ -40,7 +46,7 @@ export interface Configuration {
     /**
      * The MMKV instance's encryption/decryption key. By default, MMKV stores all key-values in plain text on file, relying on iOS's sandbox to make sure the file is encrypted. Should you worry about information leaking, you can choose to encrypt MMKV.
      *
-     * Encryption keys can have a maximum length of 16 bytes.
+     * Encryption keys can have a maximum length of 16 bytes with AES-128 encryption and 32 bytes with AES-256 encryption.
      *
      * @example
      * ```ts
@@ -50,6 +56,21 @@ export interface Configuration {
      * @default undefined
      */
     encryptionKey?: string;
+    /**
+     * The encryption algorithm to use when an encryption key is provided.
+     *
+     * @example
+     * ```ts
+     * const secureStorage = createMMKV({
+     *   id: 'secure-storage',
+     *   encryptionKey: 'my-encryption-key!',
+     *   encryptionType: 'AES-256'
+     * })
+     * ```
+     *
+     * @default 'AES-128'
+     */
+    encryptionType?: EncryptionType;
     /**
      * Configure the processing mode for MMKV.
      *
@@ -62,6 +83,14 @@ export interface Configuration {
      * @default false
      */
     readOnly?: boolean;
+    /**
+     * If `true`, MMKV will internally compare a value for equality before writing to
+     * disk, and if the new value is equal to what is already stored, it will skip
+     * the file write.
+     * Treat this as an optional performance optimization.
+     * @default false
+     */
+    compareBeforeSet?: boolean;
 }
 export interface MMKVFactory extends HybridObject<{
     ios: 'c++';

package/nitrogen/generated/android/NitroMmkvOnLoad.cpp

@@ -22,33 +22,43 @@
 namespace margelo::nitro::mmkv {
 
 int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::mmkv::registerAllNatives();
+  });
+}
+
+struct JHybridMMKVPlatformContextSpecImpl: public jni::JavaClass<JHybridMMKVPlatformContextSpecImpl, JHybridMMKVPlatformContextSpec::JavaPart> {
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContext;";
+  static std::shared_ptr<JHybridMMKVPlatformContextSpec> create() {
+    static auto constructorFn = javaClassStatic()->getConstructor<JHybridMMKVPlatformContextSpecImpl::javaobject()>();
+    jni::local_ref<JHybridMMKVPlatformContextSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridMMKVPlatformContextSpec();
+  }
+};
+
+void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace margelo::nitro::mmkv;
-  using namespace facebook;
-
-  return facebook::jni::initialize(vm, [] {
-    // Register native JNI methods
-    margelo::nitro::mmkv::JHybridMMKVPlatformContextSpec::registerNatives();
-
-    // Register Nitro Hybrid Objects
-    HybridObjectRegistry::registerHybridObjectConstructor(
-      "MMKVFactory",
-      []() -> std::shared_ptr<HybridObject> {
-        static_assert(std::is_default_constructible_v<HybridMMKVFactory>,
-                      "The HybridObject \"HybridMMKVFactory\" is not default-constructible! "
-                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
-        return std::make_shared<HybridMMKVFactory>();
-      }
-    );
-    HybridObjectRegistry::registerHybridObjectConstructor(
-      "MMKVPlatformContext",
-      []() -> std::shared_ptr<HybridObject> {
-        static DefaultConstructableObject<JHybridMMKVPlatformContextSpec::javaobject> object("com/margelo/nitro/mmkv/HybridMMKVPlatformContext");
-        auto instance = object.create();
-        return instance->cthis()->shared();
-      }
-    );
-  });
+
+  // Register native JNI methods
+  margelo::nitro::mmkv::JHybridMMKVPlatformContextSpec::CxxPart::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MMKVFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMMKVFactory>,
+                    "The HybridObject \"HybridMMKVFactory\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMMKVFactory>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MMKVPlatformContext",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridMMKVPlatformContextSpecImpl::create();
+    }
+  );
 }
 
 } // namespace margelo::nitro::mmkv

package/nitrogen/generated/android/NitroMmkvOnLoad.hpp

@@ -6,20 +6,29 @@
 ///
 
 #include <jni.h>
+#include <functional>
 #include <NitroModules/NitroDefines.hpp>
 
 namespace margelo::nitro::mmkv {
 
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
   /**
-   * Initializes the native (C++) part of NitroMmkv, and autolinks all Hybrid Objects.
-   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Register the native (C++) part of NitroMmkv, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
    * Example:
    * ```cpp (cpp-adapter.cpp)
    * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-   *   return margelo::nitro::mmkv::initialize(vm);
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroMmkv HybridObjects
+   *     margelo::nitro::mmkv::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
    * }
    * ```
    */
-  int initialize(JavaVM* vm);
+  void registerAllNatives();
 
 } // namespace margelo::nitro::mmkv

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

@@ -14,37 +14,31 @@
 
 namespace margelo::nitro::mmkv {
 
-  jni::local_ref<JHybridMMKVPlatformContextSpec::jhybriddata> JHybridMMKVPlatformContextSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
-  }
-
-  void JHybridMMKVPlatformContextSpec::registerNatives() {
-    registerHybrid({
-      makeNativeMethod("initHybrid", JHybridMMKVPlatformContextSpec::initHybrid),
-    });
+  std::shared_ptr<JHybridMMKVPlatformContextSpec> JHybridMMKVPlatformContextSpec::JavaPart::getJHybridMMKVPlatformContextSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridMMKVPlatformContextSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridMMKVPlatformContextSpec!");
+    }
+    return castHybridObject;
   }
 
-  size_t JHybridMMKVPlatformContextSpec::getExternalMemorySize() noexcept {
-    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
-    return method(_javaPart);
+  jni::local_ref<JHybridMMKVPlatformContextSpec::CxxPart::jhybriddata> JHybridMMKVPlatformContextSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
   }
 
-  bool JHybridMMKVPlatformContextSpec::equals(const std::shared_ptr<HybridObject>& other) {
-    if (auto otherCast = std::dynamic_pointer_cast<JHybridMMKVPlatformContextSpec>(other)) {
-      return _javaPart == otherCast->_javaPart;
+  std::shared_ptr<JHybridObject> JHybridMMKVPlatformContextSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridMMKVPlatformContextSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridMMKVPlatformContextSpec::JavaPart!");
     }
-    return false;
-  }
-
-  void JHybridMMKVPlatformContextSpec::dispose() noexcept {
-    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
-    method(_javaPart);
+    return std::make_shared<JHybridMMKVPlatformContextSpec>(castJavaPart);
   }
 
-  std::string JHybridMMKVPlatformContextSpec::toString() {
-    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
-    auto javaString = method(_javaPart);
-    return javaString->toStdString();
+  void JHybridMMKVPlatformContextSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridMMKVPlatformContextSpec::CxxPart::initHybrid),
+    });
   }
 
   // Properties
@@ -52,12 +46,12 @@ namespace margelo::nitro::mmkv {
 
   // Methods
   std::string JHybridMMKVPlatformContextSpec::getBaseDirectory() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getBaseDirectory");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getBaseDirectory");
     auto __result = method(_javaPart);
     return __result->toStdString();
   }
   std::optional<std::string> JHybridMMKVPlatformContextSpec::getAppGroupDirectory() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getAppGroupDirectory");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getAppGroupDirectory");
     auto __result = method(_javaPart);
     return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
   }

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

@@ -18,34 +18,33 @@ namespace margelo::nitro::mmkv {
 
   using namespace facebook;
 
-  class JHybridMMKVPlatformContextSpec: public jni::HybridClass<JHybridMMKVPlatformContextSpec, JHybridObject>,
-                                        public virtual HybridMMKVPlatformContextSpec {
+  class JHybridMMKVPlatformContextSpec: public virtual HybridMMKVPlatformContextSpec, public virtual JHybridObject {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContextSpec;";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
-    static void registerNatives();
-
-  protected:
-    // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridMMKVPlatformContextSpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridMMKVPlatformContextSpec::TAG),
-      HybridBase(jThis),
-      _javaPart(jni::make_global(jThis)) {}
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContextSpec;";
+      std::shared_ptr<JHybridMMKVPlatformContextSpec> getJHybridMMKVPlatformContextSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContextSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
 
   public:
+    explicit JHybridMMKVPlatformContextSpec(const jni::local_ref<JHybridMMKVPlatformContextSpec::JavaPart>& javaPart):
+      HybridObject(HybridMMKVPlatformContextSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
     ~JHybridMMKVPlatformContextSpec() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
 
   public:
-    size_t getExternalMemorySize() noexcept override;
-    bool equals(const std::shared_ptr<HybridObject>& other) override;
-    void dispose() noexcept override;
-    std::string toString() override;
-
-  public:
-    inline const jni::global_ref<JHybridMMKVPlatformContextSpec::javaobject>& getJavaPart() const noexcept {
+    inline const jni::global_ref<JHybridMMKVPlatformContextSpec::JavaPart>& getJavaPart() const noexcept {
       return _javaPart;
     }
 
@@ -59,9 +58,7 @@ namespace margelo::nitro::mmkv {
     std::optional<std::string> getAppGroupDirectory() override;
 
   private:
-    friend HybridBase;
-    using HybridBase::HybridBase;
-    jni::global_ref<JHybridMMKVPlatformContextSpec::javaobject> _javaPart;
+    jni::global_ref<JHybridMMKVPlatformContextSpec::JavaPart> _javaPart;
   };
 
 } // namespace margelo::nitro::mmkv

package/nitrogen/generated/android/kotlin/com/margelo/nitro/mmkv/HybridMMKVPlatformContextSpec.kt

@@ -24,23 +24,6 @@ import com.margelo.nitro.core.HybridObject
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
 abstract class HybridMMKVPlatformContextSpec: HybridObject() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    super.updateNative(mHybridData)
-  }
-
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-    super.updateNative(hybridData)
-  }
-
-  // Default implementation of `HybridObject.toString()`
-  override fun toString(): String {
-    return "[HybridObject MMKVPlatformContext]"
-  }
-
   // Properties
   
 
@@ -53,7 +36,21 @@ abstract class HybridMMKVPlatformContextSpec: HybridObject() {
   @Keep
   abstract fun getAppGroupDirectory(): String?
 
-  private external fun initHybrid(): HybridData
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject MMKVPlatformContext]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridMMKVPlatformContextSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridMMKVPlatformContextSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
 
   companion object {
     protected const val TAG = "HybridMMKVPlatformContextSpec"

package/nitrogen/generated/ios/NitroMmkv-Swift-Cxx-Bridge.hpp

@@ -41,7 +41,7 @@ namespace margelo::nitro::mmkv::bridge::swift {
     return optional.has_value();
   }
   inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return *optional;
+    return optional.value();
   }
   
   // pragma MARK: std::shared_ptr<HybridMMKVPlatformContextSpec>

package/nitrogen/generated/ios/swift/HybridMMKVPlatformContextSpec.swift

@@ -5,7 +5,6 @@
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
-import Foundation
 import NitroModules
 
 /// See ``HybridMMKVPlatformContextSpec``

package/nitrogen/generated/ios/swift/HybridMMKVPlatformContextSpec_cxx.swift

@@ -5,7 +5,6 @@
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
-import Foundation
 import NitroModules
 
 /**

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

@@ -28,11 +28,14 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `EncryptionType` to properly resolve imports.
+namespace margelo::nitro::mmkv { enum class EncryptionType; }
 // Forward declaration of `Mode` to properly resolve imports.
 namespace margelo::nitro::mmkv { enum class Mode; }
 
 #include <string>
 #include <optional>
+#include "EncryptionType.hpp"
 #include "Mode.hpp"
 
 namespace margelo::nitro::mmkv {
@@ -45,12 +48,14 @@ namespace margelo::nitro::mmkv {
     std::string id     SWIFT_PRIVATE;
     std::optional<std::string> path     SWIFT_PRIVATE;
     std::optional<std::string> encryptionKey     SWIFT_PRIVATE;
+    std::optional<EncryptionType> encryptionType     SWIFT_PRIVATE;
     std::optional<Mode> mode     SWIFT_PRIVATE;
     std::optional<bool> readOnly     SWIFT_PRIVATE;
+    std::optional<bool> compareBeforeSet     SWIFT_PRIVATE;
 
   public:
     Configuration() = default;
-    explicit Configuration(std::string id, std::optional<std::string> path, std::optional<std::string> encryptionKey, std::optional<Mode> mode, std::optional<bool> readOnly): id(id), path(path), encryptionKey(encryptionKey), mode(mode), readOnly(readOnly) {}
+    explicit Configuration(std::string id, std::optional<std::string> path, std::optional<std::string> encryptionKey, std::optional<EncryptionType> encryptionType, std::optional<Mode> mode, std::optional<bool> readOnly, std::optional<bool> compareBeforeSet): id(id), path(path), encryptionKey(encryptionKey), encryptionType(encryptionType), mode(mode), readOnly(readOnly), compareBeforeSet(compareBeforeSet) {}
 
   public:
     friend bool operator==(const Configuration& lhs, const Configuration& rhs) = default;
@@ -69,8 +74,10 @@ namespace margelo::nitro {
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "path"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "encryptionKey"))),
+        JSIConverter<std::optional<margelo::nitro::mmkv::EncryptionType>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "encryptionType"))),
         JSIConverter<std::optional<margelo::nitro::mmkv::Mode>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mode"))),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "readOnly")))
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "readOnly"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "compareBeforeSet")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::mmkv::Configuration& arg) {
@@ -78,8 +85,10 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "id"), JSIConverter<std::string>::toJSI(runtime, arg.id));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "path"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.path));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "encryptionKey"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.encryptionKey));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "encryptionType"), JSIConverter<std::optional<margelo::nitro::mmkv::EncryptionType>>::toJSI(runtime, arg.encryptionType));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "mode"), JSIConverter<std::optional<margelo::nitro::mmkv::Mode>>::toJSI(runtime, arg.mode));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "readOnly"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.readOnly));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "compareBeforeSet"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.compareBeforeSet));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -93,8 +102,10 @@ namespace margelo::nitro {
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "path")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "encryptionKey")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::mmkv::EncryptionType>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "encryptionType")))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::mmkv::Mode>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mode")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "readOnly")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "compareBeforeSet")))) return false;
       return true;
     }
   };

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

@@ -0,0 +1,76 @@
+///
+/// EncryptionType.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/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#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
+
+namespace margelo::nitro::mmkv {
+
+  /**
+   * An enum which can be represented as a JavaScript union (EncryptionType).
+   */
+  enum class EncryptionType {
+    AES_128      SWIFT_NAME(aes128) = 0,
+    AES_256      SWIFT_NAME(aes256) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::mmkv
+
+namespace margelo::nitro {
+
+  // C++ EncryptionType <> JS EncryptionType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::mmkv::EncryptionType> final {
+    static inline margelo::nitro::mmkv::EncryptionType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("AES-128"): return margelo::nitro::mmkv::EncryptionType::AES_128;
+        case hashString("AES-256"): return margelo::nitro::mmkv::EncryptionType::AES_256;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum EncryptionType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::mmkv::EncryptionType arg) {
+      switch (arg) {
+        case margelo::nitro::mmkv::EncryptionType::AES_128: return JSIConverter<std::string>::toJSI(runtime, "AES-128");
+        case margelo::nitro::mmkv::EncryptionType::AES_256: return JSIConverter<std::string>::toJSI(runtime, "AES-256");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert EncryptionType to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("AES-128"):
+        case hashString("AES-256"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -15,8 +15,11 @@ namespace margelo::nitro::mmkv {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridGetter("id", &HybridMMKVSpec::getId);
+      prototype.registerHybridGetter("length", &HybridMMKVSpec::getLength);
       prototype.registerHybridGetter("size", &HybridMMKVSpec::getSize);
+      prototype.registerHybridGetter("byteSize", &HybridMMKVSpec::getByteSize);
       prototype.registerHybridGetter("isReadOnly", &HybridMMKVSpec::getIsReadOnly);
+      prototype.registerHybridGetter("isEncrypted", &HybridMMKVSpec::getIsEncrypted);
       prototype.registerHybridMethod("set", &HybridMMKVSpec::set);
       prototype.registerHybridMethod("getBoolean", &HybridMMKVSpec::getBoolean);
       prototype.registerHybridMethod("getString", &HybridMMKVSpec::getString);
@@ -27,6 +30,8 @@ namespace margelo::nitro::mmkv {
       prototype.registerHybridMethod("getAllKeys", &HybridMMKVSpec::getAllKeys);
       prototype.registerHybridMethod("clearAll", &HybridMMKVSpec::clearAll);
       prototype.registerHybridMethod("recrypt", &HybridMMKVSpec::recrypt);
+      prototype.registerHybridMethod("encrypt", &HybridMMKVSpec::encrypt);
+      prototype.registerHybridMethod("decrypt", &HybridMMKVSpec::decrypt);
       prototype.registerHybridMethod("trim", &HybridMMKVSpec::trim);
       prototype.registerHybridMethod("addOnValueChangedListener", &HybridMMKVSpec::addOnValueChangedListener);
       prototype.registerHybridMethod("importAllFrom", &HybridMMKVSpec::importAllFrom);

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

@@ -13,6 +13,8 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `EncryptionType` to properly resolve imports.
+namespace margelo::nitro::mmkv { enum class EncryptionType; }
 // Forward declaration of `Listener` to properly resolve imports.
 namespace margelo::nitro::mmkv { struct Listener; }
 // Forward declaration of `HybridMMKVSpec` to properly resolve imports.
@@ -23,6 +25,7 @@ namespace margelo::nitro::mmkv { class HybridMMKVSpec; }
 #include <variant>
 #include <optional>
 #include <vector>
+#include "EncryptionType.hpp"
 #include "Listener.hpp"
 #include <functional>
 #include <memory>
@@ -56,8 +59,11 @@ namespace margelo::nitro::mmkv {
     public:
       // Properties
       virtual std::string getId() = 0;
+      virtual double getLength() = 0;
       virtual double getSize() = 0;
+      virtual double getByteSize() = 0;
       virtual bool getIsReadOnly() = 0;
+      virtual bool getIsEncrypted() = 0;
 
     public:
       // Methods
@@ -71,6 +77,8 @@ namespace margelo::nitro::mmkv {
       virtual std::vector<std::string> getAllKeys() = 0;
       virtual void clearAll() = 0;
       virtual void recrypt(const std::optional<std::string>& key) = 0;
+      virtual void encrypt(const std::string& key, std::optional<EncryptionType> encryptionType) = 0;
+      virtual void decrypt() = 0;
       virtual void trim() = 0;
       virtual Listener addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) = 0;
       virtual double importAllFrom(const std::shared_ptr<HybridMMKVSpec>& other) = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mmkv",
-  "version": "4.1.2",
+  "version": "4.3.0",
   "description": "⚡️ The fastest key/value storage for React Native.",
   "main": "lib/index",
   "module": "lib/index",
@@ -67,11 +67,11 @@
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
-    "nitrogen": "0.33.2",
+    "nitrogen": "0.35.0",
     "prettier": "^3.3.3",
     "react": "19.1.1",
     "react-native": "0.82.0",
-    "react-native-nitro-modules": "0.33.2",
+    "react-native-nitro-modules": "0.35.0",
     "typescript": "^5.8.3"
   },
   "peerDependencies": {

package/src/__tests__/hooks.test.tsx

@@ -7,6 +7,7 @@ import {
   renderHook,
   screen,
   cleanup,
+  waitFor,
 } from '@testing-library/react-native'
 import { createMMKV, useMMKVNumber, useMMKVString } from '..'
 
@@ -92,3 +93,39 @@ test('functional updates to hooks', () => {
     '4',
   ])
 })
+
+test('useMMKV hook does not miss updates that happen during subscription setup', async () => {
+  const raceKey = 'race-key'
+  const raceMMKV = createMMKV()
+
+  let simulatedRaceDone = false
+  const originalSubscribe = raceMMKV.addOnValueChangedListener.bind(raceMMKV)
+  raceMMKV.addOnValueChangedListener = ((listener) => {
+    if (!simulatedRaceDone) {
+      simulatedRaceDone = true
+      raceMMKV.set(raceKey, 'updated-before-subscribe')
+    }
+    return originalSubscribe(listener)
+  }) as typeof raceMMKV.addOnValueChangedListener
+
+  const { result } = renderHook(() => useMMKVString(raceKey, raceMMKV))
+
+  await waitFor(() => {
+    expect(result.current[0]).toBe('updated-before-subscribe')
+  })
+})
+
+test('useMMKV hook stays consistent during rapid updates', async () => {
+  const raceKey = 'rapid-key'
+  const { result } = renderHook(() => useMMKVNumber(raceKey, mmkv))
+
+  act(() => {
+    for (let i = 1; i <= 100; i++) {
+      mmkv.set(raceKey, i)
+    }
+  })
+
+  await waitFor(() => {
+    expect(result.current[0]).toBe(100)
+  })
+})