react-native-mmkv 2.10.2 → 2.11.0

package/README.md

@@ -1,5 +1,9 @@
 <a href="https://margelo.io">
-  <img src="./img/banner.svg" width="100%" />
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./img/banner-dark.png" />
+    <source media="(prefers-color-scheme: light)" srcset="./img/banner-light.png" />
+    <img alt="VisionCamera" src="./img/banner-light.png" />
+  </picture>
 </a>
 
 <div align="center">
@@ -221,6 +225,10 @@ Use [flipper-plugin-react-native-mmkv](https://github.com/muchobien/flipper-plug
 
 Use [reactotron-react-native-mmkv](https://www.npmjs.com/package/reactotron-react-native-mmkv) to automatically log writes to your MMKV storage using Reactotron. [See the docs for how to setup this plugin with Reactotron.](https://www.npmjs.com/package/reactotron-react-native-mmkv)
 
+## Community Discord
+
+[**Join the Margelo Community Discord**](https://discord.gg/6CSHz2qAvA) to chat about react-native-mmkv or other Margelo libraries.
+
 ## Adopting at scale
 
 react-native-mmkv is provided _as is_, I work on it in my free time.

package/android/build.gradle

@@ -48,6 +48,13 @@ repositories {
 android {
   namespace = "com.reactnativemmkv"
   compileSdkVersion safeExtGet("compileSdkVersion", 28)
+  def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+
+  if (agpVersion.tokenize('.')[0].toInteger() >= 8) {
+      buildFeatures {
+          buildConfig = true
+      }
+  }
 
   // Used to override the NDK path/version on internal CI or by allowing
   // users to customize the NDK path/version from their root project (e.g. for M1 support)

package/android/src/main/cpp/MmkvHostObject.cpp

@@ -13,12 +13,16 @@
 #include <string>
 #include <vector>
 
-MmkvHostObject::MmkvHostObject(const std::string& instanceId, std::string path, std::string cryptKey) {
-  __android_log_print(ANDROID_LOG_INFO, "RNMMKV", "Creating MMKV instance \"%s\"... (Path: %s, Encryption-Key: %s)",
-                      instanceId.c_str(), path.c_str(), cryptKey.c_str());
+MmkvHostObject::MmkvHostObject(const std::string& instanceId, std::string path,
+                               std::string cryptKey) {
+  bool hasEncryptionKey = cryptKey.size() > 0;
+  __android_log_print(ANDROID_LOG_INFO, "RNMMKV",
+                      "Creating MMKV instance \"%s\"... (Path: %s, Encrypted: %b)",
+                      instanceId.c_str(), path.c_str(), hasEncryptionKey);
   std::string* pathPtr = path.size() > 0 ? &path : nullptr;
   std::string* cryptKeyPtr = cryptKey.size() > 0 ? &cryptKey : nullptr;
-  instance = MMKV::mmkvWithID(instanceId, mmkv::DEFAULT_MMAP_SIZE, MMKV_SINGLE_PROCESS, cryptKeyPtr, pathPtr);
+  instance = MMKV::mmkvWithID(instanceId, mmkv::DEFAULT_MMAP_SIZE, MMKV_SINGLE_PROCESS, cryptKeyPtr,
+                              pathPtr);
 
   if (instance == nullptr) {
     // Check if instanceId is invalid
@@ -28,7 +32,8 @@ MmkvHostObject::MmkvHostObject(const std::string& instanceId, std::string path,
 
     // Check if encryptionKey is invalid
     if (cryptKey.size() > 16) {
-      throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer than 16 bytes!");
+      throw std::runtime_error(
+          "Failed to create MMKV instance! `encryptionKey` cannot be longer than 16 bytes!");
     }
 
     throw std::runtime_error("Failed to create MMKV instance!");
@@ -56,247 +61,229 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
 
   if (propName == "set") {
     // MMKV.set(key: string, value: string | number | bool | Uint8Array)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 2,  // key, value
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "MMKV::set: First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        2, // key, value
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime,
+                               "MMKV::set: First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
 
-      if (arguments[1].isBool()) {
-        // bool
-        instance->set(arguments[1].getBool(), keyName);
-      } else if (arguments[1].isNumber()) {
-        // number
-        instance->set(arguments[1].getNumber(), keyName);
-      } else if (arguments[1].isString()) {
-        // string
-        auto stringValue = arguments[1].getString(runtime).utf8(runtime);
-        instance->set(stringValue, keyName);
-      } else if (arguments[1].isObject()) {
-        // object
-        auto object = arguments[1].asObject(runtime);
-        if (isTypedArray(runtime, object)) {
-          // Uint8Array
-          auto typedArray = getTypedArray(runtime, object);
-          auto bufferValue = typedArray.getBuffer(runtime);
-          mmkv::MMBuffer buffer(bufferValue.data(runtime),
-                                bufferValue.size(runtime),
-                                mmkv::MMBufferCopyFlag::MMBufferNoCopy);
-          instance->set(buffer, keyName);
-        } else {
-          // unknown object
-          throw jsi::JSError(runtime, "MMKV::set: 'value' argument is an object, but not of type Uint8Array!");
-        }
-      } else {
-        // unknown type
-        throw jsi::JSError(runtime, "MMKV::set: 'value' argument is not of type bool, number, string or buffer!");
-      }
+          if (arguments[1].isBool()) {
+            // bool
+            instance->set(arguments[1].getBool(), keyName);
+          } else if (arguments[1].isNumber()) {
+            // number
+            instance->set(arguments[1].getNumber(), keyName);
+          } else if (arguments[1].isString()) {
+            // string
+            auto stringValue = arguments[1].getString(runtime).utf8(runtime);
+            instance->set(stringValue, keyName);
+          } else if (arguments[1].isObject()) {
+            // object
+            auto object = arguments[1].asObject(runtime);
+            if (isTypedArray(runtime, object)) {
+              // Uint8Array
+              auto typedArray = getTypedArray(runtime, object);
+              auto bufferValue = typedArray.getBuffer(runtime);
+              mmkv::MMBuffer buffer(bufferValue.data(runtime), bufferValue.size(runtime),
+                                    mmkv::MMBufferCopyFlag::MMBufferNoCopy);
+              instance->set(buffer, keyName);
+            } else {
+              // unknown object
+              throw jsi::JSError(
+                  runtime, "MMKV::set: 'value' argument is an object, but not of type Uint8Array!");
+            }
+          } else {
+            // unknown type
+            throw jsi::JSError(
+                runtime,
+                "MMKV::set: 'value' argument is not of type bool, number, string or buffer!");
+          }
 
-      return jsi::Value::undefined();
-    });
+          return jsi::Value::undefined();
+        });
   }
 
   if (propName == "getBoolean") {
     // MMKV.getBoolean(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      bool hasValue;
-      auto value = instance->getBool(keyName, false, &hasValue);
-      if (hasValue) {
-        return jsi::Value(value);
-      } else {
-        return jsi::Value::undefined();
-      }
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          bool hasValue;
+          auto value = instance->getBool(keyName, false, &hasValue);
+          if (hasValue) {
+            return jsi::Value(value);
+          } else {
+            return jsi::Value::undefined();
+          }
+        });
   }
 
   if (propName == "getString") {
     // MMKV.getString(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      std::string result;
-      bool hasValue = instance->getString(keyName, result);
-      if (hasValue) {
-        return jsi::Value(runtime, jsi::String::createFromUtf8(runtime, result));
-      } else {
-        return jsi::Value::undefined();
-      }
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          std::string result;
+          bool hasValue = instance->getString(keyName, result);
+          if (hasValue) {
+            return jsi::Value(runtime, jsi::String::createFromUtf8(runtime, result));
+          } else {
+            return jsi::Value::undefined();
+          }
+        });
   }
 
   if (propName == "getNumber") {
     // MMKV.getNumber(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      bool hasValue;
-      auto value = instance->getDouble(keyName, 0.0, &hasValue);
-      if (hasValue) {
-        return jsi::Value(value);
-      } else {
-        return jsi::Value::undefined();
-      }
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          bool hasValue;
+          auto value = instance->getDouble(keyName, 0.0, &hasValue);
+          if (hasValue) {
+            return jsi::Value(value);
+          } else {
+            return jsi::Value::undefined();
+          }
+        });
   }
 
+  if (propName == "getBuffer") {
+    // MMKV.getBuffer(key: string)
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-    if (propName == "getBuffer") {
-        // MMKV.getBuffer(key: string)
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, funcName),
-                                                     1,  // key
-                                                     [this](jsi::Runtime& runtime,
-                                                            const jsi::Value& thisValue,
-                                                            const jsi::Value* arguments,
-                                                            size_t count) -> jsi::Value {
-        if (!arguments[0].isString()) {
-          throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-        }
-
-        auto keyName = arguments[0].getString(runtime).utf8(runtime);
-        mmkv::MMBuffer buffer;
-        bool hasValue = instance->getBytes(keyName, buffer);
-        if (hasValue) {
-          auto length = buffer.length();
-          TypedArray<TypedArrayKind::Uint8Array> array(runtime, length);
-          auto data = static_cast<const unsigned char*>(buffer.getPtr());
-          std::vector<unsigned char> vector(length);
-          vector.assign(data, data + length);
-          array.update(runtime, vector);
-          return array;
-        } else {
-          return jsi::Value::undefined();
-        }
-      });
-    }
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          mmkv::MMBuffer buffer;
+          bool hasValue = instance->getBytes(keyName, buffer);
+          if (hasValue) {
+            auto length = buffer.length();
+            TypedArray<TypedArrayKind::Uint8Array> array(runtime, length);
+            auto data = static_cast<const unsigned char*>(buffer.getPtr());
+            std::vector<unsigned char> vector(length);
+            vector.assign(data, data + length);
+            array.update(runtime, vector);
+            return array;
+          } else {
+            return jsi::Value::undefined();
+          }
+        });
+  }
 
   if (propName == "contains") {
     // MMKV.contains(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      bool containsKey = instance->containsKey(keyName);
-      return jsi::Value(containsKey);
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          bool containsKey = instance->containsKey(keyName);
+          return jsi::Value(containsKey);
+        });
   }
 
   if (propName == "delete") {
     // MMKV.delete(key: string)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1,  // key
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (!arguments[0].isString()) {
-        throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      }
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // key
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (!arguments[0].isString()) {
+            throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
+          }
 
-      auto keyName = arguments[0].getString(runtime).utf8(runtime);
-      instance->removeValueForKey(keyName);
-      return jsi::Value::undefined();
-    });
+          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          instance->removeValueForKey(keyName);
+          return jsi::Value::undefined();
+        });
   }
 
   if (propName == "getAllKeys") {
     // MMKV.getAllKeys()
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 0,
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      auto keys = instance->allKeys();
-      auto array = jsi::Array(runtime, keys.size());
-      for (int i = 0; i < keys.size(); i++) {
-        array.setValueAtIndex(runtime, i, keys[i]);
-      }
-      return array;
-    });
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName), 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          auto keys = instance->allKeys();
+          auto array = jsi::Array(runtime, keys.size());
+          for (int i = 0; i < keys.size(); i++) {
+            array.setValueAtIndex(runtime, i, keys[i]);
+          }
+          return array;
+        });
   }
 
   if (propName == "clearAll") {
     // MMKV.clearAll()
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 0,
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      instance->clearAll();
-      return jsi::Value::undefined();
-    });
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName), 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          instance->clearAll();
+          return jsi::Value::undefined();
+        });
   }
 
   if (propName == "recrypt") {
     // MMKV.recrypt(encryptionKey)
-    return jsi::Function::createFromHostFunction(runtime,
-                                                 jsi::PropNameID::forAscii(runtime, funcName),
-                                                 1, // encryptionKey
-                                                 [this](jsi::Runtime& runtime,
-                                                        const jsi::Value& thisValue,
-                                                        const jsi::Value* arguments,
-                                                        size_t count) -> jsi::Value {
-      if (arguments[0].isUndefined()) {
-        // reset encryption key to "no encryption"
-        instance->reKey(std::string());
-      } else if (arguments[0].isString()) {
-        // reKey(..) with new encryption-key
-        auto encryptionKey = arguments[0].getString(runtime).utf8(runtime);
-        instance->reKey(encryptionKey);
-      } else {
-        throw jsi::JSError(runtime, "First argument ('encryptionKey') has to be of type string (or undefined)!");
-      }
-      return jsi::Value::undefined();
-    });
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, funcName),
+        1, // encryptionKey
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+               size_t count) -> jsi::Value {
+          if (arguments[0].isUndefined()) {
+            // reset encryption key to "no encryption"
+            instance->reKey(std::string());
+          } else if (arguments[0].isString()) {
+            // reKey(..) with new encryption-key
+            auto encryptionKey = arguments[0].getString(runtime).utf8(runtime);
+            instance->reKey(encryptionKey);
+          } else {
+            throw jsi::JSError(
+                runtime,
+                "First argument ('encryptionKey') has to be of type string (or undefined)!");
+          }
+          return jsi::Value::undefined();
+        });
   }
 
   return jsi::Value::undefined();

package/android/src/main/cpp/MmkvHostObject.h

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include <jsi/jsi.h>
 #include <MMKV.h>
+#include <jsi/jsi.h>
 
 using namespace facebook;
 
-class JSI_EXPORT MmkvHostObject: public jsi::HostObject {
+class JSI_EXPORT MmkvHostObject : public jsi::HostObject {
 public:
   MmkvHostObject(const std::string& instanceId, std::string path, std::string cryptKey);