react-native-mmkv 4.1.2 → 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.2.4'
+  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:8.13.1"
+    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.2.4"
+  implementation "io.github.zhongwuzw:mmkv:2.4.0"
 }
 

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,6 +1,7 @@
 #include "NitroMmkvOnLoad.hpp"
+#include <fbjni/fbjni.h>
 #include <jni.h>
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-  return margelo::nitro::mmkv::initialize(vm);
+  return facebook::jni::initialize(vm, []() { margelo::nitro::mmkv::registerAllNatives(); });
 }

package/cpp/HybridMMKV.cpp

@@ -14,40 +14,51 @@
 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;
-  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);
-#else
-  instance = MMKV::mmkvWithID(config.id, DEFAULT_MMAP_SIZE, mode, encryptionKeyPtr, pathPtr);
-#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!");
     }
 
-    // Check if encryptionKey is invalid
-    if (encryptionKey.size() > 16) [[unlikely]] {
-      throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer "
-                               "than 16 bytes!");
+    if (useAes256Encryption) {
+      // With AES-256, the max key length is 32 bytes.
+      if (encryptionKey.size() > 32) [[unlikely]] {
+        throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer "
+                                 "than 32 bytes with AES-256 encryption!");
+      }
+    } else {
+      // With AES-128, the max key length is 16 bytes.
+      if (encryptionKey.size() > 16) [[unlikely]] {
+        throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer "
+                                 "than 16 bytes with AES-128 encryption!");
+      }
     }
 
     // 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!");
     }
 
@@ -58,13 +69,27 @@ HybridMMKV::HybridMMKV(const Configuration& config) : HybridObject(TAG) {
 std::string HybridMMKV::getId() {
   return instance->mmapID();
 }
+
+double HybridMMKV::getLength() {
+  return instance->count();
+}
+
 double HybridMMKV::getSize() {
+  return getByteSize();
+}
+
+double HybridMMKV::getByteSize() {
   return instance->actualSize();
 }
+
 bool HybridMMKV::getIsReadOnly() {
   return instance->isReadOnly();
 }
 
+bool HybridMMKV::getIsEncrypted() {
+  return instance->isEncryptionEnabled();
+}
+
 // helper: overload pattern matching for lambdas
 template <class... Ts>
 struct overloaded : Ts... {
@@ -79,31 +104,32 @@ 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 + "\"!");
   }
 
   // Notify on changed
   MMKVValueChangedListenerRegistry::notifyOnValueChanged(instance->mmapID(), key);
 }
+
 std::optional<bool> HybridMMKV::getBoolean(const std::string& key) {
   bool hasValue;
   bool result = instance->getBool(key, /* defaultValue */ false, &hasValue);
@@ -113,6 +139,7 @@ std::optional<bool> HybridMMKV::getBoolean(const std::string& key) {
     return std::nullopt;
   }
 }
+
 std::optional<std::string> HybridMMKV::getString(const std::string& key) {
   std::string result;
   bool hasValue = instance->getString(key, result, /* inplaceModification */ true);
@@ -122,6 +149,7 @@ std::optional<std::string> HybridMMKV::getString(const std::string& key) {
     return std::nullopt;
   }
 }
+
 std::optional<double> HybridMMKV::getNumber(const std::string& key) {
   bool hasValue;
   double result = instance->getDouble(key, /* defaultValue */ 0.0, &hasValue);
@@ -131,25 +159,21 @@ std::optional<double> HybridMMKV::getNumber(const std::string& key) {
     return std::nullopt;
   }
 }
+
 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 {
     return std::nullopt;
   }
 }
+
 bool HybridMMKV::contains(const std::string& key) {
   return instance->containsKey(key);
 }
+
 bool HybridMMKV::remove(const std::string& key) {
   bool wasRemoved = instance->removeValueForKey(key);
   if (wasRemoved) {
@@ -158,9 +182,11 @@ bool HybridMMKV::remove(const std::string& key) {
   }
   return wasRemoved;
 }
+
 std::vector<std::string> HybridMMKV::getAllKeys() {
   return instance->allKeys();
 }
+
 void HybridMMKV::clearAll() {
   auto keysBefore = getAllKeys();
   instance->clearAll();
@@ -169,19 +195,30 @@ void HybridMMKV::clearAll() {
     MMKVValueChangedListenerRegistry::notifyOnValueChanged(instance->mmapID(), key);
   }
 }
+
 void HybridMMKV::recrypt(const std::optional<std::string>& key) {
-  bool successful = false;
   if (key.has_value()) {
-    // Encrypt with the given key
-    successful = instance->reKey(key.value());
+    encrypt(key.value(), std::nullopt);
   } else {
-    // Remove the encryption key by setting it to a blank string
-    successful = instance->reKey(std::string());
+    decrypt();
   }
+}
+
+void HybridMMKV::encrypt(const std::string& key, std::optional<EncryptionType> encryptionType) {
+  bool isAes256Encryption = encryptionType == EncryptionType::AES_256;
+  bool successful = instance->reKey(key, isAes256Encryption);
   if (!successful) {
-    throw std::runtime_error("Failed to recrypt MMKV instance!");
+    throw std::runtime_error("Failed to encrypt MMKV instance!");
   }
 }
+
+void HybridMMKV::decrypt() {
+  bool successful = instance->reKey("");
+  if (!successful) [[unlikely]] {
+    throw std::runtime_error("Failed to decrypt MMKV instance!");
+  }
+}
+
 void HybridMMKV::trim() {
   instance->trim();
   instance->clearMemoryCache();
@@ -190,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()
@@ -207,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/HybridMMKV.hpp

@@ -21,7 +21,10 @@ public:
   // Properties
   std::string getId() override;
   double getSize() override;
+  double getByteSize() override;
+  double getLength() override;
   bool getIsReadOnly() override;
+  bool getIsEncrypted() override;
 
 public:
   // Methods
@@ -35,6 +38,8 @@ public:
   std::vector<std::string> getAllKeys() override;
   void clearAll() override;
   void recrypt(const std::optional<std::string>& key) override;
+  void encrypt(const std::string& key, std::optional<EncryptionType> encryptionType) override;
+  void decrypt() override;
   void trim() override;
   Listener addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) override;
   double importAllFrom(const std::shared_ptr<HybridMMKVSpec>& other) override;

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/__tests__/hooks.test.js

@@ -1,6 +1,6 @@
 import React from 'react';
 import { Button, Text } from 'react-native';
-import { act, fireEvent, render, renderHook, screen, cleanup, } from '@testing-library/react-native';
+import { act, fireEvent, render, renderHook, screen, cleanup, waitFor, } from '@testing-library/react-native';
 import { createMMKV, useMMKVNumber, useMMKVString } from '..';
 const mmkv = createMMKV();
 beforeEach(() => {
@@ -67,3 +67,32 @@ 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);
+    });
+    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/lib/createMMKV/createMMKV.web.js

@@ -24,8 +24,18 @@ export function createMMKV(config = { id: 'mmkv.default' }) {
     };
     return {
         id: config.id,
-        size: 0,
+        get length() {
+            return getLocalStorage().length;
+        },
+        get size() {
+            return this.byteSize;
+        },
+        get byteSize() {
+            // estimate - assumes UTF8
+            return JSON.stringify(getLocalStorage()).length;
+        },
         isReadOnly: false,
+        isEncrypted: false,
         clearAll: () => {
             const storage = getLocalStorage();
             const keys = Object.keys(storage);
@@ -90,6 +100,12 @@ export function createMMKV(config = { id: 'mmkv.default' }) {
         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/lib/createMMKV/createMockMMKV.js

@@ -11,10 +11,18 @@ export function createMockMMKV(config = { id: 'mmkv.default' }) {
     };
     return {
         id: config.id,
-        get size() {
+        get length() {
             return storage.size;
         },
+        get size() {
+            return this.byteSize;
+        },
+        get byteSize() {
+            // estimate - assumes UTF8
+            return JSON.stringify(storage).length;
+        },
         isReadOnly: false,
+        isEncrypted: false,
         clearAll: () => {
             const keysBefore = storage.keys();
             storage.clear();
@@ -57,6 +65,12 @@ export function createMockMMKV(config = { id: 'mmkv.default' }) {
         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/lib/hooks/createMMKVHook.js

@@ -1,16 +1,16 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useSyncExternalStore } from 'react';
 import { getDefaultMMKVInstance } from '../createMMKV/getDefaultMMKVInstance';
 export function createMMKVHook(getter) {
     return (key, instance) => {
         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) => {
+            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((v) => {
             const newValue = typeof v === 'function' ? v(getter(mmkv, key)) : v;
@@ -35,15 +35,6 @@ export function createMMKVHook(getter) {
                     throw new Error(`MMKV: Type ${typeof newValue} is not supported!`);
             }
         }, [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];
     };
 }

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

@@ -1,4 +1,5 @@
 import type { HybridObject } from 'react-native-nitro-modules';
+import type { EncryptionType } from './MMKVFactory.nitro';
 export interface Listener {
     remove: () => void;
 }
@@ -10,15 +11,31 @@ export interface MMKV extends HybridObject<{
      * Get the ID of this {@linkcode MMKV} instance.
      */
     readonly id: string;
+    /**
+     * Get the current amount of key/value pairs stored in
+     * this storage.
+     */
+    readonly length: number;
     /**
      * Get the current total size of the storage, in bytes.
+     * @deprecated Use {@linkcode byteSize} instead.
      */
     readonly size: number;
     /**
-     * Returns whether this instance is in read-only mode or not.
+     * Get the current total size of the storage, in bytes.
+     */
+    readonly byteSize: number;
+    /**
+     * Get whether this instance is in read-only mode or not.
      * If this is `true`, you can only use "get"-functions.
      */
     readonly isReadOnly: boolean;
+    /**
+     * Get whether this instance is encrypted, or not.
+     * @see {@linkcode encrypt | encrypt(...)}
+     * @see {@linkcode decrypt | decrypt()}
+     */
+    readonly isEncrypted: boolean;
     /**
      * Set a {@linkcode value} for the given {@linkcode key}.
      *
@@ -77,8 +94,36 @@ export interface MMKV extends HybridObject<{
      * Encryption keys can have a maximum length of 16 bytes.
      *
      * @throws an Error if the instance cannot be recrypted.
+     * @deprecated Use {@linkcode encrypt | encrypt(...)} or {@linkcode decrypt | decrypt()} instead.
      */
     recrypt(key: string | undefined): void;
+    /**
+     * Encrypts the data in this MMKV instance with the
+     * given {@linkcode key} and {@linkcode encryptionType}.
+     *
+     * If this MMKV instance is already encrypted ({@linkcode isEncrypted}),
+     * it will re-encrypt the data.
+     *
+     * Future attempts to open this MMKV instance will require the same
+     * {@linkcode key} and {@linkcode encryptionType}, otherwise reads
+     * will fail.
+     *
+     * The {@linkcode key} must be 16-bytes in {@linkcode EncryptionType | 'AES-128'}
+     * encryption (the default), or 32-bytes in {@linkcode EncryptionType | 'AES-256'}
+     * encryption.
+     *
+     * @param key The encryption key to use. In AES-128 this must be 16-bytes, in AES-256 it must be 32-bytes long.
+     * @param encryptionType The encryption type to use. Default: AES-128
+     */
+    encrypt(key: string, encryptionType?: EncryptionType): void;
+    /**
+     * Decrypts the data in this MMKV instance and removes
+     * the encryption key.
+     *
+     * Future attempts to open this MMKV instance must be done
+     * without an encryption key, as it is now plain-text.
+     */
+    decrypt(): void;
     /**
      * Trims the storage space and clears memory cache.
      *