react-native-mmkv 4.2.0 → 4.3.0

package/NitroMmkv.podspec

@@ -24,13 +24,20 @@ Pod::Spec.new do |s|
 
   # Add MMKV Core dependency
   s.compiler_flags = '-x objective-c++'
-  s.dependency 'MMKVCore', '2.3.0'
+  s.dependency 'MMKVCore', '2.4.0'
+
+  # Optionally configure MMKV log level via Podfile ($MMKVLogLevel) or env var (MMKV_LOG_LEVEL)
+  mmkv_log_level = $MMKVLogLevel || ENV['MMKV_LOG_LEVEL']
+  gcc_preprocessor_defs = "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
+  if mmkv_log_level != nil && mmkv_log_level.to_s != ""
+    gcc_preprocessor_defs += " MMKV_LOG_LEVEL=#{mmkv_log_level}"
+  end
 
   # TODO: Remove when no one uses RN 0.79 anymore
   # Add support for React Native 0.79 or below
   s.pod_target_xcconfig = {
     "HEADER_SEARCH_PATHS" => ["${PODS_ROOT}/RCT-Folly"],
-    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES",
+    "GCC_PREPROCESSOR_DEFINITIONS" => gcc_preprocessor_defs,
     "OTHER_CPLUSPLUSFLAGS" => "$(inherited) -DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1"
   }
 

package/android/CMakeLists.txt

@@ -5,6 +5,11 @@ set (PACKAGE_NAME NitroMmkv)
 set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 20)
 
+# Optionally configure MMKV log level (passed from Gradle as -DMMKV_LOG_LEVEL=<0-4>)
+if(DEFINED MMKV_LOG_LEVEL)
+  add_definitions(-DMMKV_LOG_LEVEL=${MMKV_LOG_LEVEL})
+endif()
+
 # Find all C++ files (shared and platform specifics)
 file(GLOB_RECURSE shared_files RELATIVE ${CMAKE_SOURCE_DIR}
      "../cpp/**.cpp"

package/android/build.gradle

@@ -5,7 +5,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:9.0.0"
+    classpath "com.android.tools.build:gradle:9.1.0"
   }
 }
 
@@ -49,7 +49,12 @@ android {
     externalNativeBuild {
       cmake {
         cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
-        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        def mmkvLogLevel = rootProject.hasProperty("MMKV_logLevel") ? rootProject.property("MMKV_logLevel") : null
+        if (mmkvLogLevel != null && mmkvLogLevel != "") {
+          arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON", "-DMMKV_LOG_LEVEL=${mmkvLogLevel}"
+        } else {
+          arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        }
         abiFilters (*reactNativeArchitectures())
 
         buildTypes {
@@ -140,6 +145,6 @@ dependencies {
   implementation project(":react-native-nitro-modules")
 
   // Add a dependency on mmkv core (this ships a C++ prefab)
-  implementation "io.github.zhongwuzw:mmkv:2.3.0"
+  implementation "io.github.zhongwuzw:mmkv:2.4.0"
 }
 

package/cpp/HybridMMKV.cpp

@@ -14,31 +14,32 @@
 namespace margelo::nitro::mmkv {
 
 HybridMMKV::HybridMMKV(const Configuration& config) : HybridObject(TAG) {
-  std::string path = config.path.has_value() ? config.path.value() : "";
-  std::string encryptionKey = config.encryptionKey.has_value() ? config.encryptionKey.value() : "";
+  MMKVMode mmkvMode = getMMKVMode(config);
+  if (config.readOnly.value_or(false)) {
+    mmkvMode = mmkvMode | MMKVMode::MMKV_READ_ONLY;
+  }
+  bool useAes256Encryption = config.encryptionType.value_or(EncryptionType::AES_128) == EncryptionType::AES_256;
+  std::string encryptionKey = config.encryptionKey.value_or("");
+  std::string* encryptionKeyPtr = encryptionKey.size() > 0 ? &encryptionKey : nullptr;
+  std::string rootPath = config.path.value_or("");
+  std::string* rootPathPtr = rootPath.size() > 0 ? &rootPath : nullptr;
+  bool compareBeforeSet = config.compareBeforeSet.value_or(false);
+
+  MMKVConfig mmkvConfig{.mode = mmkvMode,
+                        .aes256 = useAes256Encryption,
+                        .cryptKey = encryptionKeyPtr,
+                        .rootPath = rootPathPtr,
+                        .enableCompareBeforeSet = compareBeforeSet};
+
   bool hasEncryptionKey = encryptionKey.size() > 0;
-  Logger::log(LogLevel::Info, TAG, "Creating MMKV instance \"%s\"... (Path: %s, Encrypted: %s)", config.id.c_str(), path.c_str(),
+  Logger::log(LogLevel::Info, TAG, "Creating MMKV instance \"%s\"... (Path: %s, Encrypted: %s)", config.id.c_str(), rootPath.c_str(),
               hasEncryptionKey ? "true" : "false");
 
-  std::string* pathPtr = path.size() > 0 ? &path : nullptr;
-  std::string* encryptionKeyPtr = encryptionKey.size() > 0 ? &encryptionKey : nullptr;
-  size_t defaultExpectedCapacity = 0;
-  bool useAes256Encryption = config.encryptionType.has_value() && config.encryptionType.value() == EncryptionType::AES_256;
-  MMKVMode mode = getMMKVMode(config);
-  if (config.readOnly.has_value() && config.readOnly.value()) {
-    Logger::log(LogLevel::Info, TAG, "Instance is read-only!");
-    mode = mode | ::mmkv::MMKV_READ_ONLY;
-  }
-
-#ifdef __APPLE__
-  instance = MMKV::mmkvWithID(config.id, mode, encryptionKeyPtr, pathPtr, defaultExpectedCapacity, useAes256Encryption);
-#else
-  instance = MMKV::mmkvWithID(config.id, DEFAULT_MMAP_SIZE, mode, encryptionKeyPtr, pathPtr, defaultExpectedCapacity, useAes256Encryption);
-#endif
+  instance = MMKV::mmkvWithID(config.id, mmkvConfig);
 
   if (instance == nullptr) [[unlikely]] {
     // Check if instanceId is invalid
-    if (config.id.empty()) [[unlikely]] {
+    if (config.id.empty()) {
       throw std::runtime_error("Failed to create MMKV instance! `id` cannot be empty!");
     }
 
@@ -57,7 +58,7 @@ HybridMMKV::HybridMMKV(const Configuration& config) : HybridObject(TAG) {
     }
 
     // Check if path is maybe invalid
-    if (path.empty()) [[unlikely]] {
+    if (rootPath.empty()) [[unlikely]] {
       throw std::runtime_error("Failed to create MMKV instance! `path` cannot be empty!");
     }
 
@@ -103,25 +104,25 @@ void HybridMMKV::set(const std::string& key, const std::variant<bool, std::share
   }
 
   // Pattern-match each potential value in std::variant
-  bool didSet = std::visit(overloaded{[&](bool b) {
-                                        // boolean
-                                        return instance->set(b, key);
-                                      },
-                                      [&](const std::shared_ptr<ArrayBuffer>& buf) {
-                                        // ArrayBuffer
-                                        MMBuffer buffer(buf->data(), buf->size(), MMBufferCopyFlag::MMBufferNoCopy);
-                                        return instance->set(std::move(buffer), key);
-                                      },
-                                      [&](const std::string& string) {
-                                        // string
-                                        return instance->set(string, key);
-                                      },
-                                      [&](double number) {
-                                        // number
-                                        return instance->set(number, key);
-                                      }},
-                           value);
-  if (!didSet) {
+  bool successful = std::visit(overloaded{[&](bool b) {
+                                            // boolean
+                                            return instance->set(b, key);
+                                          },
+                                          [&](const std::shared_ptr<ArrayBuffer>& buf) {
+                                            // ArrayBuffer
+                                            MMBuffer buffer(buf->data(), buf->size(), MMBufferCopyFlag::MMBufferNoCopy);
+                                            return instance->set(std::move(buffer), key);
+                                          },
+                                          [&](const std::string& string) {
+                                            // string
+                                            return instance->set(string, key);
+                                          },
+                                          [&](double number) {
+                                            // number
+                                            return instance->set(number, key);
+                                          }},
+                               value);
+  if (!successful) [[unlikely]] {
     throw std::runtime_error("Failed to set value for key \"" + key + "\"!");
   }
 
@@ -161,14 +162,7 @@ std::optional<double> HybridMMKV::getNumber(const std::string& key) {
 
 std::optional<std::shared_ptr<ArrayBuffer>> HybridMMKV::getBuffer(const std::string& key) {
   MMBuffer result;
-#ifdef __APPLE__
-  // iOS: Convert std::string to NSString* for MMKVCore pod compatibility
-  bool hasValue = instance->getBytes(@(key.c_str()), result);
-#else
-  // Android/other platforms: Use std::string directly (converts to
-  // std::string_view)
   bool hasValue = instance->getBytes(key, result);
-#endif
   if (hasValue) {
     return std::make_shared<ManagedMMBuffer>(std::move(result));
   } else {
@@ -220,7 +214,7 @@ void HybridMMKV::encrypt(const std::string& key, std::optional<EncryptionType> e
 
 void HybridMMKV::decrypt() {
   bool successful = instance->reKey("");
-  if (!successful) {
+  if (!successful) [[unlikely]] {
     throw std::runtime_error("Failed to decrypt MMKV instance!");
   }
 }
@@ -233,7 +227,7 @@ void HybridMMKV::trim() {
 Listener HybridMMKV::addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) {
   // Add listener
   auto mmkvID = instance->mmapID();
-  auto listenerID = MMKVValueChangedListenerRegistry::addListener(instance->mmapID(), onValueChanged);
+  auto listenerID = MMKVValueChangedListenerRegistry::addListener(mmkvID, onValueChanged);
 
   return Listener([=]() {
     // remove()
@@ -250,14 +244,13 @@ MMKVMode HybridMMKV::getMMKVMode(const Configuration& config) {
       return ::mmkv::MMKV_SINGLE_PROCESS;
     case Mode::MULTI_PROCESS:
       return ::mmkv::MMKV_MULTI_PROCESS;
-    default:
-      [[unlikely]] throw std::runtime_error("Invalid MMKV Mode value!");
   }
+  throw std::runtime_error("Invalid MMKV Mode value!");
 }
 
 double HybridMMKV::importAllFrom(const std::shared_ptr<HybridMMKVSpec>& other) {
   auto hybridMMKV = std::dynamic_pointer_cast<HybridMMKV>(other);
-  if (hybridMMKV == nullptr) {
+  if (hybridMMKV == nullptr) [[unlikely]] {
     throw std::runtime_error("The given `MMKV` instance is not of type `HybridMMKV`!");
   }
 

package/cpp/HybridMMKVFactory.cpp

@@ -18,11 +18,7 @@ std::string HybridMMKVFactory::getDefaultMMKVInstanceId() {
 void HybridMMKVFactory::initializeMMKV(const std::string& rootPath) {
   Logger::log(LogLevel::Info, TAG, "Initializing MMKV with rootPath=%s", rootPath.c_str());
 
-#ifdef NITRO_DEBUG
-  MMKVLogLevel logLevel = ::mmkv::MMKVLogDebug;
-#else
-  MMKVLogLevel logLevel = ::mmkv::MMKVLogWarning;
-#endif
+  MMKVLogLevel logLevel = static_cast<MMKVLogLevel>(MMKV_LOG_LEVEL);
   MMKV::initializeMMKV(rootPath, logLevel);
 }
 

package/cpp/MMKVTypes.hpp

@@ -48,3 +48,15 @@ constexpr auto MMKV_READ_ONLY = ::MMKVMode::MMKV_READ_ONLY;
  */
 
 using namespace mmkv;
+
+// Default MMKV log level if not configured at build time
+#ifndef MMKV_LOG_LEVEL
+#ifdef NITRO_DEBUG
+#define MMKV_LOG_LEVEL 0
+#else
+#define MMKV_LOG_LEVEL 3
+#endif
+#endif
+#if MMKV_LOG_LEVEL < 0 || MMKV_LOG_LEVEL > 4
+#error "MMKV_LOG_LEVEL must be between 0 (Debug) and 4 (None)"
+#endif

package/cpp/ManagedMMBuffer.hpp

@@ -15,7 +15,7 @@ namespace margelo::nitro::mmkv {
 /**
  An ArrayBuffer subclass that manages MMBuffer memory (by ownership).
  */
-class ManagedMMBuffer : public ArrayBuffer {
+class ManagedMMBuffer final : public ArrayBuffer {
 public:
   explicit ManagedMMBuffer(MMBuffer&& buffer) : _buffer(std::move(buffer)) {}
 

package/lib/createMMKV/createMMKV.web.js

@@ -31,7 +31,7 @@ export function createMMKV(config = { id: 'mmkv.default' }) {
             return this.byteSize;
         },
         get byteSize() {
-            // esimate - assumes UTF8
+            // estimate - assumes UTF8
             return JSON.stringify(getLocalStorage()).length;
         },
         isReadOnly: false,

package/lib/createMMKV/createMockMMKV.js

@@ -18,7 +18,7 @@ export function createMockMMKV(config = { id: 'mmkv.default' }) {
             return this.byteSize;
         },
         get byteSize() {
-            // esimate - assumes UTF8
+            // estimate - assumes UTF8
             return JSON.stringify(storage).length;
         },
         isReadOnly: false,

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

@@ -99,7 +99,7 @@ export interface MMKV extends HybridObject<{
     recrypt(key: string | undefined): void;
     /**
      * Encrypts the data in this MMKV instance with the
-     * given {@linkcode key} and {@linkcode ecnryptionType}.
+     * given {@linkcode key} and {@linkcode encryptionType}.
      *
      * If this MMKV instance is already encrypted ({@linkcode isEncrypted}),
      * it will re-encrypt the data.

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

@@ -83,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/shared/c++/Configuration.hpp

@@ -51,10 +51,11 @@ namespace margelo::nitro::mmkv {
     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<EncryptionType> encryptionType, std::optional<Mode> mode, std::optional<bool> readOnly): id(id), path(path), encryptionKey(encryptionKey), encryptionType(encryptionType), 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;
@@ -75,7 +76,8 @@ namespace margelo::nitro {
         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) {
@@ -86,6 +88,7 @@ namespace margelo::nitro {
       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) {
@@ -102,6 +105,7 @@ namespace margelo::nitro {
       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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mmkv",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "⚡️ The fastest key/value storage for React Native.",
   "main": "lib/index",
   "module": "lib/index",

package/src/createMMKV/createMMKV.web.ts

@@ -46,7 +46,7 @@ export function createMMKV(
       return this.byteSize
     },
     get byteSize(): number {
-      // esimate - assumes UTF8
+      // estimate - assumes UTF8
       return JSON.stringify(getLocalStorage()).length
     },
     isReadOnly: false,

package/src/createMMKV/createMockMMKV.ts

@@ -25,7 +25,7 @@ export function createMockMMKV(
       return this.byteSize
     },
     get byteSize(): number {
-      // esimate - assumes UTF8
+      // estimate - assumes UTF8
       return JSON.stringify(storage).length
     },
     isReadOnly: false,

package/src/specs/MMKV.nitro.ts

@@ -98,7 +98,7 @@ export interface MMKV extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   recrypt(key: string | undefined): void
   /**
    * Encrypts the data in this MMKV instance with the
-   * given {@linkcode key} and {@linkcode ecnryptionType}.
+   * given {@linkcode key} and {@linkcode encryptionType}.
    *
    * If this MMKV instance is already encrypted ({@linkcode isEncrypted}),
    * it will re-encrypt the data.

package/src/specs/MMKVFactory.nitro.ts

@@ -86,6 +86,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