react-native-mmkv 4.1.1 → 4.2.0

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/NitroMmkvAutolinking.swift

@@ -5,16 +5,13 @@
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
 public final class NitroMmkvAutolinking {
   public typealias bridge = margelo.nitro.mmkv.bridge.swift
 
-  /**
-   * Creates an instance of a Swift class that implements `HybridMMKVPlatformContextSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridMMKVPlatformContextSpec_cxx`)
-   *
-   * This is generated by Nitrogen and will initialize the class specified
-   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridMMKVPlatformContext`).
-   */
   public static func createMMKVPlatformContext() -> bridge.std__shared_ptr_HybridMMKVPlatformContextSpec_ {
     let hybridObject = HybridMMKVPlatformContext()
     return { () -> bridge.std__shared_ptr_HybridMMKVPlatformContextSpec_ in
@@ -22,4 +19,8 @@ public final class NitroMmkvAutolinking {
       return __cxxWrapped.getCxxPart()
     }()
   }
+  
+  public static func isMMKVPlatformContextRecyclable() -> Bool {
+    return HybridMMKVPlatformContext.self is any RecyclableView.Type
+  }
 }

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

@@ -5,7 +5,6 @@
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
-import Foundation
 import NitroModules
 
 /// See ``HybridMMKVPlatformContextSpec``
@@ -31,14 +30,14 @@ open class HybridMMKVPlatformContextSpec_base {
   public init() { }
   public func getCxxWrapper() -> HybridMMKVPlatformContextSpec_cxx {
   #if DEBUG
-    guard self is HybridMMKVPlatformContextSpec else {
+    guard self is any HybridMMKVPlatformContextSpec else {
       fatalError("`self` is not a `HybridMMKVPlatformContextSpec`! Did you accidentally inherit from `HybridMMKVPlatformContextSpec_base` instead of `HybridMMKVPlatformContextSpec`?")
     }
   #endif
     if let cxxWrapper = self.cxxWrapper {
       return cxxWrapper
     } else {
-      let cxxWrapper = HybridMMKVPlatformContextSpec_cxx(self as! HybridMMKVPlatformContextSpec)
+      let cxxWrapper = HybridMMKVPlatformContextSpec_cxx(self as! any HybridMMKVPlatformContextSpec)
       self.cxxWrapper = cxxWrapper
       return cxxWrapper
     }

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,13 @@ 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;
 
   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): id(id), path(path), encryptionKey(encryptionKey), encryptionType(encryptionType), mode(mode), readOnly(readOnly) {}
 
   public:
     friend bool operator==(const Configuration& lhs, const Configuration& rhs) = default;
@@ -69,6 +73,7 @@ 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")))
       );
@@ -78,6 +83,7 @@ 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));
       return obj;
@@ -93,6 +99,7 @@ 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;
       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.1",
+  "version": "4.2.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.32.1",
+    "nitrogen": "0.35.0",
     "prettier": "^3.3.3",
     "react": "19.1.1",
     "react-native": "0.82.0",
-    "react-native-nitro-modules": "0.32.1",
+    "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)
+  })
+})

package/src/createMMKV/createMMKV.web.ts

@@ -39,8 +39,18 @@ export function createMMKV(
 
   return {
     id: config.id,
-    size: 0,
+    get length(): number {
+      return getLocalStorage().length
+    },
+    get size(): number {
+      return this.byteSize
+    },
+    get byteSize(): number {
+      // esimate - assumes UTF8
+      return JSON.stringify(getLocalStorage()).length
+    },
     isReadOnly: false,
+    isEncrypted: false,
     clearAll: () => {
       const storage = getLocalStorage()
       const keys = Object.keys(storage)
@@ -100,6 +110,12 @@ export function createMMKV(
     recrypt: () => {
       throw new Error('`recrypt(..)` is not supported on Web!')
     },
+    encrypt: () => {
+      throw new Error('`encrypt(..)` is not supported on Web!')
+    },
+    decrypt: () => {
+      throw new Error('`decrypt(..)` is not supported on Web!')
+    },
     trim: () => {
       // no-op
     },

package/src/createMMKV/createMockMMKV.ts

@@ -18,10 +18,18 @@ export function createMockMMKV(
 
   return {
     id: config.id,
-    get size(): number {
+    get length(): number {
       return storage.size
     },
+    get size(): number {
+      return this.byteSize
+    },
+    get byteSize(): number {
+      // esimate - assumes UTF8
+      return JSON.stringify(storage).length
+    },
     isReadOnly: false,
+    isEncrypted: false,
     clearAll: () => {
       const keysBefore = storage.keys()
       storage.clear()
@@ -63,6 +71,12 @@ export function createMockMMKV(
     recrypt: () => {
       console.warn('Encryption is not supported in mocked MMKV instances!')
     },
+    encrypt: () => {
+      console.warn('Encryption is not supported in mocked MMKV instances!')
+    },
+    decrypt: () => {
+      console.warn('Encryption is not supported in mocked MMKV instances!')
+    },
     trim: () => {
       // no-op
     },

package/src/hooks/createMMKVHook.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
+import { useCallback, useSyncExternalStore } from 'react'
 import { getDefaultMMKVInstance } from '../createMMKV/getDefaultMMKVInstance'
 import type { MMKV } from '../specs/MMKV.nitro'
 
@@ -13,14 +13,21 @@ export function createMMKVHook<
   ): [value: T, setValue: (value: TSetAction) => void] => {
     const mmkv = instance ?? getDefaultMMKVInstance()
 
-    const [bump, setBump] = useState(0)
-    const value = useMemo(() => {
-      // bump is here as an additional outside dependency, so this useMemo
-      // re-computes the value each time bump changes, effectively acting as a hint
-      // that the outside value (storage) has changed. setting bump refreshes this value.
-      bump
-      return getter(mmkv, key)
-    }, [mmkv, key, bump])
+    const value = useSyncExternalStore(
+      useCallback(
+        (onStoreChange: () => void) => {
+          const listener = mmkv.addOnValueChangedListener((changedKey) => {
+            if (changedKey === key) {
+              onStoreChange()
+            }
+          })
+          return () => listener.remove()
+        },
+        [key, mmkv]
+      ),
+      useCallback(() => getter(mmkv, key), [key, mmkv]),
+      useCallback(() => getter(mmkv, key), [key, mmkv])
+    )
 
     // update value by user set
     const set = useCallback(
@@ -51,16 +58,6 @@ export function createMMKVHook<
       [key, mmkv]
     )
 
-    // update value if it changes somewhere else (second hook, same key)
-    useEffect(() => {
-      const listener = mmkv.addOnValueChangedListener((changedKey) => {
-        if (changedKey === key) {
-          setBump((b) => b + 1)
-        }
-      })
-      return () => listener.remove()
-    }, [key, mmkv])
-
     return [value, set]
   }
 }