react-native-mmkv 4.1.2 → 4.2.0

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

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

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

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

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

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

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

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

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

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

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

@@ -28,11 +28,14 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `EncryptionType` to properly resolve imports.
+namespace margelo::nitro::mmkv { enum class EncryptionType; }
 // Forward declaration of `Mode` to properly resolve imports.
 namespace margelo::nitro::mmkv { enum class Mode; }
 
 #include <string>
 #include <optional>
+#include "EncryptionType.hpp"
 #include "Mode.hpp"
 
 namespace margelo::nitro::mmkv {
@@ -45,12 +48,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.2",
+  "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.33.2",
+    "nitrogen": "0.35.0",
     "prettier": "^3.3.3",
     "react": "19.1.1",
     "react-native": "0.82.0",
-    "react-native-nitro-modules": "0.33.2",
+    "react-native-nitro-modules": "0.35.0",
     "typescript": "^5.8.3"
   },
   "peerDependencies": {

package/src/__tests__/hooks.test.tsx

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

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]
   }
 }

package/src/specs/MMKV.nitro.ts

@@ -1,4 +1,5 @@
 import type { HybridObject } from 'react-native-nitro-modules'
+import type { EncryptionType } from './MMKVFactory.nitro'
 
 export interface Listener {
   remove: () => void
@@ -9,15 +10,31 @@ export interface MMKV extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
    * 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}.
    *
@@ -76,8 +93,36 @@ export interface MMKV extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
    * 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 ecnryptionType}.
+   *
+   * 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.
    *

package/src/specs/MMKVFactory.nitro.ts

@@ -8,6 +8,13 @@ import type { MMKV } from './MMKV.nitro'
  */
 export type Mode = 'single-process' | 'multi-process'
 
+/**
+ * Configures the encryption algorithm for the MMKV instance.
+ * - `AES-128`: Uses AES-128 encryption (default).
+ * - `AES-256`: Uses AES-256 encryption for enhanced security.
+ */
+export type EncryptionType = 'AES-128' | 'AES-256'
+
 /**
  * Used for configuration of a single MMKV instance.
  */
@@ -42,7 +49,7 @@ export interface Configuration {
   /**
    * The MMKV instance's encryption/decryption key. By default, MMKV stores all key-values in plain text on file, relying on iOS's sandbox to make sure the file is encrypted. Should you worry about information leaking, you can choose to encrypt MMKV.
    *
-   * Encryption keys can have a maximum length of 16 bytes.
+   * Encryption keys can have a maximum length of 16 bytes with AES-128 encryption and 32 bytes with AES-256 encryption.
    *
    * @example
    * ```ts
@@ -52,6 +59,21 @@ export interface Configuration {
    * @default undefined
    */
   encryptionKey?: string
+  /**
+   * The encryption algorithm to use when an encryption key is provided.
+   *
+   * @example
+   * ```ts
+   * const secureStorage = createMMKV({
+   *   id: 'secure-storage',
+   *   encryptionKey: 'my-encryption-key!',
+   *   encryptionType: 'AES-256'
+   * })
+   * ```
+   *
+   * @default 'AES-128'
+   */
+  encryptionType?: EncryptionType
   /**
    * Configure the processing mode for MMKV.
    *