react-native-mmkv 2.12.2 → 3.0.0-beta.2

package/{android/src/main/cpp → cpp}/MmkvHostObject.cpp

@@ -7,31 +7,39 @@
 //
 
 #include "MmkvHostObject.h"
-#include "TypedArray.h"
+#include "Logger.h"
+#include "MMKVManagedBuffer.h"
 #include <MMKV.h>
-#include <android/log.h>
 #include <string>
 #include <vector>
 
-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);
+using namespace mmkv;
+
+MmkvHostObject::MmkvHostObject(const facebook::react::MMKVConfig& config) {
+  std::string path = config.path.has_value() ? config.path.value() : "";
+  std::string encryptionKey = config.encryptionKey.has_value() ? config.encryptionKey.value() : "";
+  bool hasEncryptionKey = encryptionKey.size() > 0;
+  Logger::log("RNMMKV", "Creating MMKV instance \"%s\"... (Path: %s, Encrypted: %s)",
+              config.id.c_str(), path.c_str(), hasEncryptionKey ? "true" : "false");
+
   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);
+  std::string* encryptionKeyPtr = encryptionKey.size() > 0 ? &encryptionKey : nullptr;
+  MMKVMode mode = getMMKVMode(config);
+
+#ifdef __APPLE__
+  instance = MMKV::mmkvWithID(config.id, mode, encryptionKeyPtr, pathPtr);
+#else
+  instance = MMKV::mmkvWithID(config.id, DEFAULT_MMAP_SIZE, mode, encryptionKeyPtr, pathPtr);
+#endif
 
   if (instance == nullptr) {
     // Check if instanceId is invalid
-    if (instanceId.empty()) {
+    if (config.id.empty()) {
       throw std::runtime_error("Failed to create MMKV instance! `id` cannot be empty!");
     }
 
     // Check if encryptionKey is invalid
-    if (cryptKey.size() > 16) {
+    if (encryptionKey.size() > 16) {
       throw std::runtime_error(
           "Failed to create MMKV instance! `encryptionKey` cannot be longer than 16 bytes!");
     }
@@ -40,8 +48,18 @@ MmkvHostObject::MmkvHostObject(const std::string& instanceId, std::string path,
   }
 }
 
+MmkvHostObject::~MmkvHostObject() {
+  if (instance != nullptr) {
+    std::string instanceId = instance->mmapID();
+    Logger::log("RNMMKV", "Destroying MMKV instance \"%s\"...", instanceId.c_str());
+    instance->clearMemoryCache();
+  }
+  instance = nullptr;
+}
+
 std::vector<jsi::PropNameID> MmkvHostObject::getPropertyNames(jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> result;
+  result.reserve(12);
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("set")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("getBoolean")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("getBuffer")));
@@ -52,26 +70,44 @@ std::vector<jsi::PropNameID> MmkvHostObject::getPropertyNames(jsi::Runtime& rt)
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("getAllKeys")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteAll")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("recrypt")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("trim")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("size")));
   return result;
 }
 
+MMKVMode MmkvHostObject::getMMKVMode(const facebook::react::MMKVConfig& config) {
+  if (!config.mode.has_value()) {
+    return MMKVMode::MMKV_SINGLE_PROCESS;
+  }
+  auto mode = config.mode.value();
+  switch (mode) {
+    case facebook::react::MmkvCxxMode::SINGLE_PROCESS:
+      return MMKVMode::MMKV_SINGLE_PROCESS;
+    case facebook::react::MmkvCxxMode::MULTI_PROCESS:
+      return MMKVMode::MMKV_MULTI_PROCESS;
+    default:
+      throw std::runtime_error("Invalid MMKV Mode value!");
+  }
+}
+
 jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& propNameId) {
   auto propName = propNameId.utf8(runtime);
   auto funcName = "MMKV." + propName;
 
   if (propName == "set") {
-    // MMKV.set(key: string, value: string | number | bool | Uint8Array)
+    // MMKV.set(key: string, value: string | number | bool | ArrayBuffer)
     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()) {
+          if (count != 2 || !arguments[0].isString()) {
+            [[unlikely]];
             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].asString(runtime).utf8(runtime);
 
           if (arguments[1].isBool()) {
             // bool
@@ -81,22 +117,21 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
             instance->set(arguments[1].getNumber(), keyName);
           } else if (arguments[1].isString()) {
             // string
-            auto stringValue = arguments[1].getString(runtime).utf8(runtime);
+            auto stringValue = arguments[1].asString(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);
+            if (object.isArrayBuffer(runtime)) {
+              // ArrayBuffer
+              auto arrayBuffer = object.getArrayBuffer(runtime);
+              MMBuffer data(arrayBuffer.data(runtime), arrayBuffer.size(runtime), MMBufferNoCopy);
+              instance->set(data, keyName);
             } else {
               // unknown object
               throw jsi::JSError(
-                  runtime, "MMKV::set: 'value' argument is an object, but not of type Uint8Array!");
+                  runtime,
+                  "MMKV::set: 'value' argument is an object, but not of type ArrayBuffer!");
             }
           } else {
             // unknown type
@@ -116,62 +151,65 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // key
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
-          if (!arguments[0].isString()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
           }
 
-          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
           bool hasValue;
           auto value = instance->getBool(keyName, false, &hasValue);
-          if (hasValue) {
-            return jsi::Value(value);
-          } else {
+          if (!hasValue) {
+            [[unlikely]];
             return jsi::Value::undefined();
           }
+          return jsi::Value(value);
         });
   }
 
-  if (propName == "getString") {
-    // MMKV.getString(key: string)
+  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()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             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 {
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
+          bool hasValue;
+          auto value = instance->getDouble(keyName, 0.0, &hasValue);
+          if (!hasValue) {
+            [[unlikely]];
             return jsi::Value::undefined();
           }
+          return jsi::Value(value);
         });
   }
 
-  if (propName == "getNumber") {
-    // MMKV.getNumber(key: string)
+  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()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             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 {
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
+          std::string result;
+          bool hasValue = instance->getString(keyName, result);
+          if (!hasValue) {
+            [[unlikely]];
             return jsi::Value::undefined();
           }
+          return jsi::Value(runtime, jsi::String::createFromUtf8(runtime, result));
         });
   }
 
@@ -182,24 +220,20 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // key
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
-          if (!arguments[0].isString()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
           }
 
-          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].asString(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 {
+          if (!hasValue) {
+            [[unlikely]];
             return jsi::Value::undefined();
           }
+          auto mutableData = std::make_shared<MMKVManagedBuffer>(std::move(buffer));
+          return jsi::ArrayBuffer(runtime, mutableData);
         });
   }
 
@@ -210,11 +244,12 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // key
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
-          if (!arguments[0].isString()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
           }
 
-          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
           bool containsKey = instance->containsKey(keyName);
           return jsi::Value(containsKey);
         });
@@ -227,11 +262,12 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // key
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
-          if (!arguments[0].isString()) {
+          if (count != 1 || !arguments[0].isString()) {
+            [[unlikely]];
             throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
           }
 
-          auto keyName = arguments[0].getString(runtime).utf8(runtime);
+          auto keyName = arguments[0].asString(runtime).utf8(runtime);
           instance->removeValueForKey(keyName);
           return jsi::Value::undefined();
         });
@@ -270,6 +306,12 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
         1, // encryptionKey
         [this](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
                size_t count) -> jsi::Value {
+          if (count != 1) {
+            [[unlikely]];
+            throw jsi::JSError(runtime, "Expected 1 argument (encryptionKey), but received " +
+                                            std::to_string(count) + "!");
+          }
+
           if (arguments[0].isUndefined()) {
             // reset encryption key to "no encryption"
             instance->reKey(std::string());
@@ -278,13 +320,34 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
             auto encryptionKey = arguments[0].getString(runtime).utf8(runtime);
             instance->reKey(encryptionKey);
           } else {
+            // Invalid argument (maybe object?)
             throw jsi::JSError(
                 runtime,
                 "First argument ('encryptionKey') has to be of type string (or undefined)!");
           }
+
           return jsi::Value::undefined();
         });
   }
 
+  if (propName == "trim") {
+    // MMKV.trim()
+    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->clearMemoryCache();
+          instance->trim();
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "size") {
+    // MMKV.size
+    size_t size = instance->actualSize();
+    return jsi::Value(static_cast<int>(size));
+  }
+
   return jsi::Value::undefined();
 }

package/{android/src/main/cpp → cpp}/MmkvHostObject.h

@@ -8,19 +8,25 @@
 
 #pragma once
 
-#include <MMKV.h>
+#include "MMKV.h"
+#include "NativeMmkvModule.h"
 #include <jsi/jsi.h>
 
 using namespace facebook;
+using namespace mmkv;
 
-class JSI_EXPORT MmkvHostObject : public jsi::HostObject {
+class MmkvHostObject : public jsi::HostObject {
 public:
-  MmkvHostObject(const std::string& instanceId, std::string path, std::string cryptKey);
+  MmkvHostObject(const facebook::react::MMKVConfig& config);
+  ~MmkvHostObject();
 
 public:
   jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) override;
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt) override;
 
+private:
+  static MMKVMode getMMKVMode(const facebook::react::MMKVConfig& config);
+
 private:
   MMKV* instance;
 };

package/cpp/NativeMmkvModule.cpp

@@ -0,0 +1,46 @@
+//
+//  NativeMmkvModule.cpp
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.2024.
+//
+
+#include "NativeMmkvModule.h"
+#include "Logger.h"
+#include "MMKV.h"
+#include "MmkvHostObject.h"
+
+namespace facebook::react {
+
+NativeMmkvModule::NativeMmkvModule(std::shared_ptr<CallInvoker> jsInvoker)
+    : NativeMmkvCxxSpec(jsInvoker) {}
+
+bool NativeMmkvModule::initialize(jsi::Runtime& runtime, std::string basePath) {
+  if (basePath.size() < 1) {
+    throw jsi::JSError(runtime, "Path cannot be empty!");
+  }
+
+  Logger::log("RNMMKV", "Initializing MMKV at %s...", basePath.c_str());
+
+#ifdef DEBUG
+  MMKVLogLevel logLevel = MMKVLogDebug;
+#else
+  MMKVLogLevel logLevel = MMKVLogWarning;
+#endif
+
+  MMKV::initializeMMKV(basePath, logLevel);
+
+  return true;
+}
+
+NativeMmkvModule::~NativeMmkvModule() {
+  Logger::log("RNMMKV", "Closing all MMKV instances...");
+  MMKV::onExit();
+}
+
+jsi::Object NativeMmkvModule::createMMKV(jsi::Runtime& runtime, MMKVConfig config) {
+  auto instance = std::make_shared<MmkvHostObject>(config);
+  return jsi::Object::createFromHostObject(runtime, instance);
+}
+
+} // namespace facebook::react

package/cpp/NativeMmkvModule.h

@@ -0,0 +1,37 @@
+//
+//  NativeMmkvModule.h
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.2024.
+//
+
+#pragma once
+
+#if __has_include(<React-Codegen/RNMmkvSpecJSI.h>)
+// CocoaPods include (iOS)
+#include <React-Codegen/RNMmkvSpecJSI.h>
+#elif __has_include(<RNMmkvSpecJSI.h>)
+// CMake include on Android
+#include <RNMmkvSpecJSI.h>
+#else
+#error Cannot find react-native-mmkv spec! Try cleaning your cache and re-running CodeGen!
+#endif
+
+namespace facebook::react {
+
+// The MMKVConfiguration type from JS
+using MMKVConfig = MmkvCxxConfiguration<std::string, std::optional<std::string>,
+                                        std::optional<std::string>, std::optional<MmkvCxxMode>>;
+template <> struct Bridging<MMKVConfig> : MmkvCxxConfigurationBridging<MMKVConfig> {};
+
+// The TurboModule itself
+class NativeMmkvModule : public NativeMmkvCxxSpec<NativeMmkvModule> {
+public:
+  NativeMmkvModule(std::shared_ptr<CallInvoker> jsInvoker);
+  ~NativeMmkvModule();
+
+  bool initialize(jsi::Runtime& runtime, std::string basePath);
+  jsi::Object createMMKV(jsi::Runtime& runtime, MMKVConfig config);
+};
+
+} // namespace facebook::react

package/ios/AppleLogger.mm

@@ -0,0 +1,16 @@
+//
+//  AppleLogger.m
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.24.
+//
+
+#import "Logger.h"
+#import <Foundation/Foundation.h>
+
+void Logger::log(const std::string& tag, const std::string& message) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wformat-security"
+  NSLog(@"[%s]: %s", tag.c_str(), message.c_str());
+#pragma clang diagnostic pop
+}

package/ios/MmkvOnLoad.mm

@@ -0,0 +1,25 @@
+//
+//  MmkvOnLoad.mm
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 27.03.24.
+//
+
+#import "NativeMmkvModule.h"
+#import <Foundation/Foundation.h>
+#import <ReactCommon/CxxTurboModuleUtils.h>
+
+@interface MMKVOnLoad : NSObject
+@end
+
+@implementation MMKVOnLoad
+
++ (void)load {
+  facebook::react::registerCxxModuleToGlobalModuleMap(
+      std::string(facebook::react::NativeMmkvModule::kModuleName),
+      [&](std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
+        return std::make_shared<facebook::react::NativeMmkvModule>(jsInvoker);
+      });
+}
+
+@end

package/ios/MmkvPlatformContext.h

@@ -0,0 +1,19 @@
+//
+//  RTNMmkvPlatformContext.h
+//  Pods
+//
+//  Created by Marc Rousavy on 27.03.24.
+//
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <RNMmkvSpec/RNMmkvSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MmkvPlatformContext : NSObject <NativeMmkvPlatformContextSpec>
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/MmkvPlatformContextModule.mm

@@ -0,0 +1,37 @@
+//
+//  AppleMmkvPlatformContext.m
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.24.
+//
+
+#import "MmkvPlatformContext.h"
+#import <Foundation/Foundation.h>
+
+@implementation MmkvPlatformContext
+
+RCT_EXPORT_MODULE()
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams&)params {
+  return std::make_shared<facebook::react::NativeMmkvPlatformContextSpecJSI>(params);
+}
+
+- (NSString*)getBaseDirectory {
+#if TARGET_OS_TV
+  NSArray* paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
+#else
+  NSArray* paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+#endif
+  NSString* documentPath = (NSString*)[paths firstObject];
+  if ([documentPath length] > 0) {
+    NSString* basePath = [documentPath stringByAppendingPathComponent:@"mmkv"];
+    return basePath;
+  } else {
+    @throw [NSException exceptionWithName:@"BasePathNotFound"
+                                   reason:@"Cannot find base-path to store MMKV files!"
+                                 userInfo:nil];
+  }
+}
+
+@end

package/lib/commonjs/LazyTurboModule.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLazyTurboModule = getLazyTurboModule;
+var _reactNative = require("react-native");
+/**
+ * Lazily get a TurboModule by wrapping it in a Proxy.
+ */
+function getLazyTurboModule(initializeTurboModule) {
+  const proxy = new Proxy({
+    module: null
+  }, {
+    get: (target, property) => {
+      if (target.module == null) {
+        // Target is null, let's initialize it!
+        target.module = initializeTurboModule();
+        if (target.module == null) {
+          // TurboModule not found, something went wrong!
+          let message = 'Failed to create a new MMKV instance: The native MMKV Module could not be found.';
+          message += '\n* Make sure react-native-mmkv is correctly autolinked (run `npx react-native config` to verify)';
+          if (_reactNative.Platform.OS === 'ios' || _reactNative.Platform.OS === 'macos') {
+            message += '\n* Make sure you ran `pod install` in the ios/ directory.';
+          }
+          if (_reactNative.Platform.OS === 'android') {
+            message += '\n* Make sure gradle is synced.';
+          }
+          // check if Expo
+          const ExpoConstants = _reactNative.NativeModules.NativeUnimoduleProxy?.modulesConstants?.ExponentConstants;
+          if (ExpoConstants != null) {
+            if (ExpoConstants.appOwnership === 'expo') {
+              // We're running Expo Go
+              throw new Error('react-native-mmkv is not supported in Expo Go! Use EAS (`expo prebuild`) or eject to a bare workflow instead.');
+            } else {
+              // We're running Expo bare / standalone
+              message += '\n* Make sure you ran `expo prebuild`.';
+            }
+          }
+          message += '\n* Make sure you rebuilt the app.';
+          throw new Error(message);
+        }
+      }
+      return target.module[property];
+    }
+  });
+  return proxy;
+}
+//# sourceMappingURL=LazyTurboModule.js.map

package/lib/commonjs/LazyTurboModule.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","getLazyTurboModule","initializeTurboModule","proxy","Proxy","module","get","target","property","message","Platform","OS","ExpoConstants","NativeModules","NativeUnimoduleProxy","modulesConstants","ExponentConstants","appOwnership","Error"],"sourceRoot":"../../src","sources":["LazyTurboModule.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAMA;AACA;AACA;AACO,SAASC,kBAAkBA,CAChCC,qBAAqC,EAClC;EACH,MAAMC,KAAK,GAAG,IAAIC,KAAK,CACrB;IACEC,MAAM,EAAE;EACV,CAAC,EACD;IACEC,GAAG,EAAEA,CAACC,MAAM,EAAEC,QAAQ,KAAK;MACzB,IAAID,MAAM,CAACF,MAAM,IAAI,IAAI,EAAE;QACzB;QACAE,MAAM,CAACF,MAAM,GAAGH,qBAAqB,CAAC,CAAC;QAEvC,IAAIK,MAAM,CAACF,MAAM,IAAI,IAAI,EAAE;UACzB;UACA,IAAII,OAAO,GACT,kFAAkF;UACpFA,OAAO,IACL,mGAAmG;UACrG,IAAIC,qBAAQ,CAACC,EAAE,KAAK,KAAK,IAAID,qBAAQ,CAACC,EAAE,KAAK,OAAO,EAAE;YACpDF,OAAO,IACL,4DAA4D;UAChE;UACA,IAAIC,qBAAQ,CAACC,EAAE,KAAK,SAAS,EAAE;YAC7BF,OAAO,IAAI,iCAAiC;UAC9C;UACA;UACA,MAAMG,aAAa,GACjBC,0BAAa,CAACC,oBAAoB,EAAEC,gBAAgB,EAChDC,iBAAiB;UACvB,IAAIJ,aAAa,IAAI,IAAI,EAAE;YACzB,IAAIA,aAAa,CAACK,YAAY,KAAK,MAAM,EAAE;cACzC;cACA,MAAM,IAAIC,KAAK,CACb,+GACF,CAAC;YACH,CAAC,MAAM;cACL;cACAT,OAAO,IAAI,wCAAwC;YACrD;UACF;UAEAA,OAAO,IAAI,oCAAoC;UAC/C,MAAM,IAAIS,KAAK,CAACT,OAAO,CAAC;QAC1B;MACF;MAEA,OAAOF,MAAM,CAACF,MAAM,CAACG,QAAQ,CAAY;IAC3C;EACF,CACF,CAAC;EACD,OAAOL,KAAK;AACd","ignoreList":[]}