react-native-mmkv 4.0.0-beta.5 → 4.0.0-beta.7

package/android/src/main/java/com/margelo/nitro/mmkv/HybridMMKVPlatformContext.kt

@@ -12,7 +12,7 @@ class HybridMMKVPlatformContext: HybridMMKVPlatformContextSpec() {
         return context.filesDir.absolutePath + "/mmkv";
     }
 
-    override fun getAppGroupDirectory(): String {
+    override fun getAppGroupDirectory(): String? {
         // AppGroups do not exist on Android. It's iOS only.
         throw Error("getAppGroupDirectory() is not supported on Android! It's iOS only.")
     }

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./lib/commonjs/expo-plugin/withMMKV')

package/cpp/HybridMMKV.hpp

@@ -0,0 +1,47 @@
+//
+//  HybridMMKV.hpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 21.08.2025.
+//
+
+#pragma once
+
+#include "Configuration.hpp"
+#include "HybridMMKVSpec.hpp"
+#include "MMKVTypes.hpp"
+
+namespace margelo::nitro::mmkv {
+
+class HybridMMKV final : public HybridMMKVSpec {
+public:
+  explicit HybridMMKV(const Configuration& configuration);
+
+public:
+  // Properties
+  double getSize() override;
+  bool getIsReadOnly() override;
+
+public:
+  // Methods
+  void set(const std::string& key, const std::variant<std::string, double, bool, std::shared_ptr<ArrayBuffer>>& value) override;
+  std::optional<bool> getBoolean(const std::string& key) override;
+  std::optional<std::string> getString(const std::string& key) override;
+  std::optional<double> getNumber(const std::string& key) override;
+  std::optional<std::shared_ptr<ArrayBuffer>> getBuffer(const std::string& key) override;
+  bool contains(const std::string& key) override;
+  void remove(const std::string& key) override;
+  std::vector<std::string> getAllKeys() override;
+  void clearAll() override;
+  void recrypt(const std::optional<std::string>& key) override;
+  void trim() override;
+  Listener addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) override;
+
+private:
+  static MMKVMode getMMKVMode(const Configuration& config);
+
+private:
+  MMKV* instance;
+};
+
+} // namespace margelo::nitro::mmkv

package/cpp/HybridMMKVFactory.hpp

@@ -0,0 +1,24 @@
+//
+//  HybridMMKVFactory.hpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 21.08.2025.
+//
+
+#pragma once
+
+#include "HybridMMKVFactorySpec.hpp"
+
+namespace margelo::nitro::mmkv {
+
+class HybridMMKVFactory final : public HybridMMKVFactorySpec {
+public:
+  HybridMMKVFactory() : HybridObject(TAG) {}
+
+public:
+  std::string getDefaultMMKVInstanceId() override;
+  std::shared_ptr<HybridMMKVSpec> createMMKV(const Configuration& configuration) override;
+  void initializeMMKV(const std::string& rootPath) override;
+};
+
+} // namespace margelo::nitro::mmkv

package/cpp/MMKVTypes.hpp

@@ -0,0 +1,50 @@
+//
+//  MMKVTypes.h
+//  react-native-mmkv
+//
+//  Created by Brad Anderson on 10.08.2025.
+//  Platform-specific MMKV type unification header
+//
+
+#pragma once
+
+// Platform-specific MMKV includes
+#ifdef __ANDROID__
+#include <MMKV/MMKV.h>
+
+// On Android, bring global namespace types into mmkv namespace for consistency
+namespace mmkv {
+using MMKV = ::MMKV;
+using MMKVMode = ::MMKVMode;
+using MMKVLogLevel = ::MMKVLogLevel;
+
+// Constants - bring into mmkv namespace
+constexpr auto MMKVLogDebug = ::MMKVLogDebug;
+constexpr auto MMKVLogInfo = ::MMKVLogInfo;
+constexpr auto MMKVLogWarning = ::MMKVLogWarning;
+constexpr auto MMKVLogError = ::MMKVLogError;
+constexpr auto MMKVLogNone = ::MMKVLogNone;
+
+constexpr auto MMKV_SINGLE_PROCESS = ::MMKV_SINGLE_PROCESS;
+constexpr auto MMKV_MULTI_PROCESS = ::MMKV_MULTI_PROCESS;
+constexpr auto MMKV_READ_ONLY = ::MMKVMode::MMKV_READ_ONLY;
+} // namespace mmkv
+
+#else
+#include <MMKVCore/MMKV.h>
+// iOS already has everything in mmkv:: namespace
+#endif
+
+/**
+ * Unified MMKV namespace usage for cross-platform compatibility.
+ *
+ * After including this header, use:
+ * - mmkv::MMKV for the main class
+ * - mmkv::MMKVMode for mode enum
+ * - mmkv::MMKVLogLevel for log level enum
+ * - mmkv::MMBuffer for buffer type
+ * - mmkv::MMKV_SINGLE_PROCESS / mmkv::MMKV_MULTI_PROCESS for modes
+ * - mmkv::MMKVLogDebug, etc. for log levels
+ */
+
+using namespace mmkv;

package/cpp/MMKVValueChangedListenerRegistry.hpp

@@ -0,0 +1,43 @@
+//
+//  MMKVValueChangedListenerRegistry.hpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 21.08.2025.
+//
+
+#include "MMKVTypes.hpp"
+#include <atomic>
+#include <unordered_map>
+
+namespace margelo::nitro::mmkv {
+
+using ListenerID = size_t;
+using MMKVID = std::string;
+
+struct ListenerSubscription {
+  ListenerID id;
+  std::function<void(const std::string& /* key */)> callback;
+};
+
+/**
+ * Listeners are tracked across instances - so we need an extra static class for
+ * the registry.
+ */
+class MMKVValueChangedListenerRegistry final {
+public:
+  MMKVValueChangedListenerRegistry() = delete;
+  ~MMKVValueChangedListenerRegistry() = delete;
+
+public:
+  static ListenerID addListener(const std::string& mmkvID, const std::function<void(const std::string& /* key */)>& callback);
+  static void removeListener(const std::string& mmkvID, ListenerID id);
+
+public:
+  static void notifyOnValueChanged(const std::string& mmkvID, const std::string& key);
+
+private:
+  static std::atomic<ListenerID> _listenersCounter;
+  static std::unordered_map<MMKVID, std::vector<ListenerSubscription>> _listeners;
+};
+
+} // namespace margelo::nitro::mmkv

package/cpp/ManagedMMBuffer.hpp

@@ -0,0 +1,40 @@
+//
+//  ManagedMMBuffer.h
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.24.
+//
+
+#pragma once
+
+#include "MMKVTypes.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::mmkv {
+
+/**
+ An ArrayBuffer subclass that manages MMBuffer memory (by ownership).
+ */
+class ManagedMMBuffer : public ArrayBuffer {
+public:
+  explicit ManagedMMBuffer(MMBuffer&& buffer) : _buffer(std::move(buffer)) {}
+
+public:
+  bool isOwner() const noexcept override {
+    return true;
+  }
+
+public:
+  uint8_t* data() override {
+    return static_cast<uint8_t*>(_buffer.getPtr());
+  }
+
+  size_t size() const override {
+    return _buffer.length();
+  }
+
+private:
+  MMBuffer _buffer;
+};
+
+} // namespace margelo::nitro::mmkv

package/ios/HybridMMKVPlatformContext.swift

@@ -5,6 +5,7 @@
 //  Created by Marc Rousavy on 25.03.24.
 //
 
+import Foundation
 import NitroModules
 
 class HybridMMKVPlatformContext: HybridMMKVPlatformContextSpec {
@@ -17,16 +18,26 @@ class HybridMMKVPlatformContext: HybridMMKVPlatformContextSpec {
   }
   
   func getBaseDirectory() throws -> String {
-    let paths = NSSearchPathForDirectoriesInDomains(Self.directory, .userDomainMask, true)
-    if let documentPath = paths.first {
-      let basePath = documentPath + "/mmkv"
-      return basePath
-    } else {
+    // Get user documents directory
+    let paths = FileManager.default.urls(for: Self.directory, in: .userDomainMask)
+    guard let documentsPath = paths.first else {
       throw RuntimeError.error(withMessage: "Cannot find base-path to store MMKV files!")
     }
+    
+    // append /mmkv to it
+    let basePath = documentsPath.appendingPathComponent("mmkv", conformingTo: .directory)
+    return basePath.path
   }
   
-  func getAppGroupDirectory() -> String {
-    return ""
+  func getAppGroupDirectory() throws -> String? {
+    // Read `AppGroupIdentifier` from `Info.plist`
+    guard let appGroupID = Bundle.main.object(forInfoDictionaryKey: "AppGroupIdentifier") as? String else {
+      return nil
+    }
+    // Get the URL for the AppGroup
+    guard let url = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: appGroupID) else {
+      throw RuntimeError.error(withMessage: "Container for AppGroup \"\(appGroupID)\" not accessible")
+    }
+    return url.path
   }
 }

package/lib/__tests__/hooks.test.js

@@ -1,12 +1,15 @@
 import React from 'react';
 import { Button, Text } from 'react-native';
-import { act, fireEvent, render, renderHook, screen, } from '@testing-library/react-native';
+import { act, fireEvent, render, renderHook, screen, cleanup, } from '@testing-library/react-native';
 import { createMMKV, useMMKVNumber, useMMKVString } from '..';
 const mmkv = createMMKV();
 beforeEach(() => {
     mmkv.clearAll();
     mmkv.trim();
 });
+afterEach(() => {
+    cleanup();
+});
 test('hooks update when the value is changed directly through the instance', () => {
     const { result } = renderHook(() => useMMKVString('string-key', mmkv));
     expect(result.current[0]).toBeUndefined();

package/lib/createMMKV/createMMKV.mock.js

@@ -4,10 +4,30 @@
 export function createMockMMKV() {
     const storage = new Map();
     const listeners = new Set();
+    const notifyListeners = (key) => {
+        listeners.forEach((listener) => {
+            listener(key);
+        });
+    };
     return {
-        clearAll: () => storage.clear(),
-        remove: (key) => storage.delete(key),
-        set: (key, value) => storage.set(key, value),
+        clearAll: () => {
+            const keysBefore = storage.keys();
+            storage.clear();
+            // Notify all listeners for all keys that were cleared
+            for (const key of keysBefore) {
+                notifyListeners(key);
+            }
+        },
+        remove: (key) => {
+            const deleted = storage.delete(key);
+            if (deleted) {
+                notifyListeners(key);
+            }
+        },
+        set: (key, value) => {
+            storage.set(key, value);
+            notifyListeners(key);
+        },
         getString: (key) => {
             const result = storage.get(key);
             return typeof result === 'string' ? result : undefined;

package/lib/expo-plugin/withMMKV.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigPlugin } from '@expo/config-plugins';
+declare const _default: ConfigPlugin<{}>;
+export default _default;

package/lib/expo-plugin/withMMKV.js

@@ -0,0 +1,17 @@
+import { createRunOncePlugin, withGradleProperties } from '@expo/config-plugins';
+const pkg = require('../../package.json');
+const withMMKV = (config) => {
+    // remove 32-bit architectures from gradle.properties
+    return withGradleProperties(config, (cfg) => {
+        // Drop any existing entry…
+        cfg.modResults = cfg.modResults.filter((p) => !(p.type === 'property' && p.key === 'reactNativeArchitectures'));
+        // …and force 64-bit only.
+        cfg.modResults.push({
+            type: 'property',
+            key: 'reactNativeArchitectures',
+            value: 'arm64-v8a,x86_64',
+        });
+        return cfg;
+    });
+};
+export default createRunOncePlugin(withMMKV, pkg.name, pkg.version);

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

@@ -15,8 +15,8 @@ export interface Configuration {
      *
      * @example
      * ```ts
-     * const userStorage = new MMKV({ id: `user-${userId}-storage` })
-     * const globalStorage = new MMKV({ id: 'global-app-storage' })
+     * const userStorage = createMMKV({ id: `user-${userId}-storage` })
+     * const globalStorage = createMMKV({ id: 'global-app-storage' })
      * ```
      *
      * @default 'mmkv.default'
@@ -27,7 +27,7 @@ export interface Configuration {
   
      * @example
      * ```ts
-     * const temporaryStorage = new MMKV({ path: '/tmp/' })
+     * const temporaryStorage = createMMKV({ path: '/tmp/' })
      * ```
      *
      * @note On iOS, if an `AppGroup` is set in `Info.plist` and `path` is `undefined`, MMKV will use the `AppGroup` directory.
@@ -44,7 +44,7 @@ export interface Configuration {
      *
      * @example
      * ```ts
-     * const secureStorage = new MMKV({ encryptionKey: 'my-encryption-key!' })
+     * const secureStorage = createMMKV({ encryptionKey: 'my-encryption-key!' })
      * ```
      *
      * @default undefined

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

@@ -9,7 +9,10 @@ export interface MMKVPlatformContext extends HybridObject<{
     getBaseDirectory(): string;
     /**
      * Get the MMKV AppGroup's directory.
+     * The AppGroup can be set in your App's `Info.plist`, and will enable
+     * data sharing between main app, companions (e.g. watch app) and extensions.
      * @platform iOS
+     * @default undefined
      */
-    getAppGroupDirectory(): string;
+    getAppGroupDirectory(): string | undefined;
 }

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

@@ -10,6 +10,7 @@
 
 
 #include <string>
+#include <optional>
 
 namespace margelo::nitro::mmkv {
 
@@ -42,10 +43,10 @@ namespace margelo::nitro::mmkv {
     auto __result = method(_javaPart);
     return __result->toStdString();
   }
-  std::string JHybridMMKVPlatformContextSpec::getAppGroupDirectory() {
+  std::optional<std::string> JHybridMMKVPlatformContextSpec::getAppGroupDirectory() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getAppGroupDirectory");
     auto __result = method(_javaPart);
-    return __result->toStdString();
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
   }
 
 } // namespace margelo::nitro::mmkv

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

@@ -54,7 +54,7 @@ namespace margelo::nitro::mmkv {
   public:
     // Methods
     std::string getBaseDirectory() override;
-    std::string getAppGroupDirectory() override;
+    std::optional<std::string> getAppGroupDirectory() override;
 
   private:
     friend HybridBase;

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

@@ -46,7 +46,7 @@ abstract class HybridMMKVPlatformContextSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun getAppGroupDirectory(): String
+  abstract fun getAppGroupDirectory(): String?
 
   private external fun initHybrid(): HybridData
 

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

@@ -20,6 +20,7 @@ namespace NitroMmkv { class HybridMMKVPlatformContextSpec_cxx; }
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <memory>
+#include <optional>
 #include <string>
 
 /**
@@ -28,6 +29,21 @@ namespace NitroMmkv { class HybridMMKVPlatformContextSpec_cxx; }
  */
 namespace margelo::nitro::mmkv::bridge::swift {
 
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridMMKVPlatformContextSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridMMKVPlatformContextSpec>`.
@@ -48,5 +64,14 @@ namespace margelo::nitro::mmkv::bridge::swift {
   inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
     return Result<std::string>::withError(error);
   }
+  
+  // pragma MARK: Result<std::optional<std::string>>
+  using Result_std__optional_std__string__ = Result<std::optional<std::string>>;
+  inline Result_std__optional_std__string__ create_Result_std__optional_std__string__(const std::optional<std::string>& value) noexcept {
+    return Result<std::optional<std::string>>::withValue(value);
+  }
+  inline Result_std__optional_std__string__ create_Result_std__optional_std__string__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::string>>::withError(error);
+  }
 
 } // namespace margelo::nitro::mmkv::bridge::swift

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

@@ -16,6 +16,7 @@ namespace margelo::nitro::mmkv { class HybridMMKVPlatformContextSpec; }
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <memory>
+#include <optional>
 #include <string>
 
 // C++ helpers for Swift

package/nitrogen/generated/ios/c++/HybridMMKVPlatformContextSpecSwift.hpp

@@ -15,6 +15,7 @@ namespace NitroMmkv { class HybridMMKVPlatformContextSpec_cxx; }
 
 
 #include <string>
+#include <optional>
 
 #include "NitroMmkv-Swift-Cxx-Umbrella.hpp"
 
@@ -65,7 +66,7 @@ namespace margelo::nitro::mmkv {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::string getAppGroupDirectory() override {
+    inline std::optional<std::string> getAppGroupDirectory() override {
       auto __result = _swiftPart.getAppGroupDirectory();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

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

@@ -15,7 +15,7 @@ public protocol HybridMMKVPlatformContextSpec_protocol: HybridObject {
 
   // Methods
   func getBaseDirectory() throws -> String
-  func getAppGroupDirectory() throws -> String
+  func getAppGroupDirectory() throws -> String?
 }
 
 /// See ``HybridMMKVPlatformContextSpec``

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

@@ -122,14 +122,20 @@ open class HybridMMKVPlatformContextSpec_cxx {
   }
   
   @inline(__always)
-  public final func getAppGroupDirectory() -> bridge.Result_std__string_ {
+  public final func getAppGroupDirectory() -> bridge.Result_std__optional_std__string__ {
     do {
       let __result = try self.__implementation.getAppGroupDirectory()
-      let __resultCpp = std.string(__result)
-      return bridge.create_Result_std__string_(__resultCpp)
+      let __resultCpp = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__string__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__string_(__exceptionPtr)
+      return bridge.create_Result_std__optional_std__string__(__exceptionPtr)
     }
   }
 }

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

@@ -16,6 +16,7 @@
 
 
 #include <string>
+#include <optional>
 
 namespace margelo::nitro::mmkv {
 
@@ -49,7 +50,7 @@ namespace margelo::nitro::mmkv {
     public:
       // Methods
       virtual std::string getBaseDirectory() = 0;
-      virtual std::string getAppGroupDirectory() = 0;
+      virtual std::optional<std::string> getAppGroupDirectory() = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mmkv",
-  "version": "4.0.0-beta.5",
+  "version": "4.0.0-beta.7",
   "description": "react-native-mmkv",
   "main": "lib/index",
   "module": "lib/index",
@@ -23,7 +23,7 @@
     "ios/**/*.cpp",
     "ios/**/*.swift",
     "cpp/**/*.h",
-    "cpp/**/*.cpp",
+    "cpp/**/*.hpp",
     "cpp/**/*.cpp",
     "app.plugin.js",
     "nitro.json",
@@ -60,6 +60,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
+    "@expo/config-plugins": "^10.1.2",
     "@react-native/eslint-config": "0.81.0",
     "@testing-library/react-native": "^13.3.1",
     "@types/jest": "^29.5.12",
@@ -67,7 +68,6 @@
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
-    "jest": "^30.0.5",
     "nitro-codegen": "*",
     "prettier": "^3.3.3",
     "react": "19.1.0",

package/src/__tests__/hooks.test.tsx

@@ -6,6 +6,7 @@ import {
   render,
   renderHook,
   screen,
+  cleanup,
 } from '@testing-library/react-native'
 import { createMMKV, useMMKVNumber, useMMKVString } from '..'
 
@@ -16,6 +17,10 @@ beforeEach(() => {
   mmkv.trim()
 })
 
+afterEach(() => {
+  cleanup()
+})
+
 test('hooks update when the value is changed directly through the instance', () => {
   const { result } = renderHook(() => useMMKVString('string-key', mmkv))
 

package/src/createMMKV/createMMKV.mock.ts

@@ -7,10 +7,31 @@ export function createMockMMKV(): MMKV {
   const storage = new Map<string, string | boolean | number | ArrayBuffer>()
   const listeners = new Set<(key: string) => void>()
 
+  const notifyListeners = (key: string) => {
+    listeners.forEach((listener) => {
+      listener(key)
+    })
+  }
+
   return {
-    clearAll: () => storage.clear(),
-    remove: (key) => storage.delete(key),
-    set: (key, value) => storage.set(key, value),
+    clearAll: () => {
+      const keysBefore = storage.keys()
+      storage.clear()
+      // Notify all listeners for all keys that were cleared
+      for (const key of keysBefore) {
+        notifyListeners(key)
+      }
+    },
+    remove: (key) => {
+      const deleted = storage.delete(key)
+      if (deleted) {
+        notifyListeners(key)
+      }
+    },
+    set: (key, value) => {
+      storage.set(key, value)
+      notifyListeners(key)
+    },
     getString: (key) => {
       const result = storage.get(key)
       return typeof result === 'string' ? result : undefined

package/src/expo-plugin/withMMKV.ts

@@ -0,0 +1,23 @@
+import type { ConfigPlugin } from '@expo/config-plugins'
+import { createRunOncePlugin, withGradleProperties } from '@expo/config-plugins'
+
+const pkg = require('../../package.json')
+
+const withMMKV: ConfigPlugin<{}> = (config) => {
+  // remove 32-bit architectures from gradle.properties
+  return withGradleProperties(config, (cfg) => {
+    // Drop any existing entry…
+    cfg.modResults = cfg.modResults.filter(
+      (p) => !(p.type === 'property' && p.key === 'reactNativeArchitectures')
+    )
+    // …and force 64-bit only.
+    cfg.modResults.push({
+      type: 'property',
+      key: 'reactNativeArchitectures',
+      value: 'arm64-v8a,x86_64',
+    })
+    return cfg
+  })
+}
+
+export default createRunOncePlugin(withMMKV, pkg.name, pkg.version)

package/src/specs/MMKVFactory.nitro.ts

@@ -17,8 +17,8 @@ export interface Configuration {
    *
    * @example
    * ```ts
-   * const userStorage = new MMKV({ id: `user-${userId}-storage` })
-   * const globalStorage = new MMKV({ id: 'global-app-storage' })
+   * const userStorage = createMMKV({ id: `user-${userId}-storage` })
+   * const globalStorage = createMMKV({ id: 'global-app-storage' })
    * ```
    *
    * @default 'mmkv.default'
@@ -29,7 +29,7 @@ export interface Configuration {
 
    * @example
    * ```ts
-   * const temporaryStorage = new MMKV({ path: '/tmp/' })
+   * const temporaryStorage = createMMKV({ path: '/tmp/' })
    * ```
    *
    * @note On iOS, if an `AppGroup` is set in `Info.plist` and `path` is `undefined`, MMKV will use the `AppGroup` directory.
@@ -46,7 +46,7 @@ export interface Configuration {
    *
    * @example
    * ```ts
-   * const secureStorage = new MMKV({ encryptionKey: 'my-encryption-key!' })
+   * const secureStorage = createMMKV({ encryptionKey: 'my-encryption-key!' })
    * ```
    *
    * @default undefined

package/src/specs/MMKVPlatformContext.nitro.ts

@@ -8,7 +8,10 @@ export interface MMKVPlatformContext
   getBaseDirectory(): string
   /**
    * Get the MMKV AppGroup's directory.
+   * The AppGroup can be set in your App's `Info.plist`, and will enable
+   * data sharing between main app, companions (e.g. watch app) and extensions.
    * @platform iOS
+   * @default undefined
    */
-  getAppGroupDirectory(): string
+  getAppGroupDirectory(): string | undefined
 }