react-native-mmkv 4.0.0-beta.1 → 4.0.0-beta.2

package/{react-native-mmkv.podspec → NitroMmkv.podspec}

@@ -2,31 +2,35 @@ require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
-Pod::UI.puts "[react-native-mmkv] Thank you for using react-native-mmkv ❤️"
-Pod::UI.puts "[react-native-mmkv] If you enjoy using react-native-mmkv, please consider sponsoring this project: https://github.com/sponsors/mrousavy"
-
 Pod::Spec.new do |s|
-  s.name         = "react-native-mmkv"
+  s.name         = "NitroMmkv"
   s.version      = package["version"]
   s.summary      = package["description"]
   s.homepage     = package["homepage"]
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => min_ios_version_supported, :tvos => "12.0", :osx => "10.14" }
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0, :tvos => "12.0", :osx => "10.14" }
   s.source       = { :git => "https://github.com/mrousavy/react-native-mmkv.git", :tag => "#{s.version}" }
 
-  s.pod_target_xcconfig = {
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-  }
-  s.compiler_flags = '-x objective-c++'
-  s.libraries    = "z", "c++"
   s.source_files = [
-    # react-native-mmkv
-    "ios/**/*.{h,m,mm}",
-    "cpp/**/*.{hpp,cpp,c,h}"
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
   ]
 
+  # Add MMKV Core dependency
+  s.compiler_flags = '-x objective-c++'
+  s.libraries    = 'z', 'c++'
   s.dependency 'MMKVCore', '>= 2.2.3'
+
+  load 'nitrogen/generated/ios/NitroMmkv+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
   install_modules_dependencies(s)
 end

package/README.md

@@ -1,5 +1,3 @@
 # react-native-mmkv
 
-The fastest key/value storage for React Native. ~30x faster than AsyncStorage!
-
-See [README.md](https://github.com/mrousavy/react-native-mmkv) for more information.
+See https://github.com/mrousavy/react-native-mmkv

package/android/CMakeLists.txt

@@ -1,41 +1,42 @@
+project(NitroMmkv)
 cmake_minimum_required(VERSION 3.9.0)
-project(ReactNativeMmkv)
-
-set(CMAKE_VERBOSE_MAKEFILE ON)
-set(CMAKE_CXX_STANDARD 20)
-
-# Check for supported ABIs only
-if(NOT (ANDROID_ABI STREQUAL "arm64-v8a" OR ANDROID_ABI STREQUAL "x86_64"))
-    message(FATAL_ERROR "MMKV prefab does not support ABI: ${ANDROID_ABI}. Supported ABIs: arm64-v8a, x86_64")
-endif()
-
-# Compile sources
-add_library(
-        react-native-mmkv
-        SHARED
-        src/main/cpp/AndroidLogger.cpp
-        ../cpp/MmkvHostObject.cpp
-        ../cpp/NativeMmkvModule.cpp
+
+set (PACKAGE_NAME NitroMmkv)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Find all C++ files (shared and platform specifics)
+file(GLOB_RECURSE shared_files RELATIVE ${CMAKE_SOURCE_DIR}
+     "../cpp/**.cpp"
+)
+file(GLOB_RECURSE android_files RELATIVE ${CMAKE_SOURCE_DIR}
+     "src/main/cpp/**.cpp"
 )
 
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../cpp)
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+            ${shared_files}
+            ${android_files}
+)
 
-# Find MMKV prefab package
+# Find MMKV prefab package (from mmkv-shared gradle dependency)
 find_package(mmkv REQUIRED CONFIG)
 
-# Add android/log dependency
-find_library(android_log log)
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroMmkv+autolinking.cmake)
 
-target_include_directories(
-        react-native-mmkv
-        PUBLIC
-        ${CMAKE_CURRENT_SOURCE_DIR}/../cpp
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "../cpp"
 )
 
+find_library(LOG_LIB log)
+
+# Link all libraries together
 target_link_libraries(
-        react-native-mmkv
-        mmkv::mmkv                  # <-- MMKV core (now manually configured)
-        ${android_log}              # <-- Logcat logger
-        android                     # <-- Android JNI core
-        react_codegen_RNMmkvSpec    # <-- Generated Specs from CodeGen
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        mmkv::mmkv                  # <-- MMKV core
+        android                     # <-- Android core
 )

package/android/build.gradle

@@ -9,29 +9,34 @@ buildscript {
   }
 }
 
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["x86_64", "arm64-v8a"]
+}
+
 def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
 apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/NitroMmkv+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
 
 if (isNewArchitectureEnabled()) {
   apply plugin: "com.facebook.react"
 }
 
 def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Mmkv_" + name]
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroMmkv_" + name]
 }
 
 def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Mmkv_" + name]).toInteger()
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroMmkv_" + name]).toInteger()
 }
 
-logger.warn("[react-native-mmkv] Thank you for using react-native-mmkv ❤️")
-logger.warn("[react-native-mmkv] If you enjoy using react-native-mmkv, please consider sponsoring this project: https://github.com/sponsors/mrousavy")
-
 android {
-  namespace "com.mrousavy.mmkv"
+  namespace "com.margelo.nitro.mmkv"
 
   ndkVersion getExtOrDefault("ndkVersion")
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
@@ -40,6 +45,50 @@ android {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
   }
 
   buildFeatures {
@@ -65,18 +114,18 @@ android {
   sourceSets {
     main {
       if (isNewArchitectureEnabled()) {
-          java.srcDirs += [
-            // This is needed to build Kotlin project with NewArch enabled
-            "${project.buildDir}/generated/source/codegen/java"
-          ]
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
       }
     }
   }
 }
 
 repositories {
-  google()
   mavenCentral()
+  google()
 }
 
 
@@ -86,14 +135,10 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 
-  // Use the MMKV shared lib - includes C++ prefabs (shared STL for React Native compatibility)
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+
+  // Add a dependency on mmkv core (this ships a C++ prefab)
   implementation "com.tencent:mmkv-shared:2.2.3"
 }
 
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "Mmkv"
-    codegenJavaPackageName = "com.mrousavy.mmkv"
-  }
-}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -1,5 +1,5 @@
-Mmkv_kotlinVersion=1.9.24
-Mmkv_minSdkVersion=23
-Mmkv_targetSdkVersion=34
-Mmkv_compileSdkVersion=34
-Mmkv_ndkversion=26.1.10909125
+NitroMmkv_kotlinVersion=2.1.20
+NitroMmkv_minSdkVersion=23
+NitroMmkv_targetSdkVersion=36
+NitroMmkv_compileSdkVersion=36
+NitroMmkv_ndkVersion=27.1.12297006

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

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

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

@@ -0,0 +1,19 @@
+package com.margelo.nitro.mmkv
+
+import androidx.annotation.Keep
+import com.facebook.common.internal.DoNotStrip
+import com.margelo.nitro.NitroModules
+
+@DoNotStrip
+@Keep
+class HybridMMKVPlatformContext: HybridMMKVPlatformContextSpec() {
+    override fun getBaseDirectory(): String {
+        val context = NitroModules.applicationContext ?: throw Error("Cannot get MMKV base directory - No Android Context available!")
+        return context.filesDir.absolutePath + "/mmkv";
+    }
+
+    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/android/src/main/java/com/margelo/nitro/mmkv/NitroMmkvPackage.java

@@ -0,0 +1,33 @@
+package com.margelo.nitro.mmkv;
+
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.TurboReactPackage;
+import com.margelo.nitro.core.HybridObject;
+
+import java.util.HashMap;
+import java.util.function.Supplier;
+
+public class NitroMmkvPackage extends TurboReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+        return new HashMap<>();
+    };
+  }
+
+  static {
+    NitroMmkvOnLoad.initializeNative();
+  }
+}

package/ios/HybridMMKVPlatformContext.swift

@@ -0,0 +1,32 @@
+//
+//  HybridMMKVPlatformContext.h
+//  react-native-mmkv
+//
+//  Created by Marc Rousavy on 25.03.24.
+//
+
+import NitroModules
+
+class HybridMMKVPlatformContext: HybridMMKVPlatformContextSpec {
+  static var directory: FileManager.SearchPathDirectory {
+#if os(tvOS)
+    return .cachesDirectory
+#else
+    return .documentDirectory
+#endif
+  }
+  
+  func getBaseDirectory() throws -> String {
+    let paths = NSSearchPathForDirectoriesInDomains(Self.directory, .userDomainMask, true)
+    if let documentPath = paths.first {
+      let basePath = documentPath + "/mmkv"
+      return basePath
+    } else {
+      throw RuntimeError.error(withMessage: "Cannot find base-path to store MMKV files!")
+    }
+  }
+  
+  func getAppGroupDirectory() -> String {
+    return ""
+  }
+}

package/lib/__tests__/hooks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/hooks.test.js

@@ -0,0 +1,66 @@
+import React from 'react';
+import { Button, Text } from 'react-native';
+import { act, fireEvent, render, renderHook, screen, } from '@testing-library/react-native';
+import { createMMKV, useMMKVNumber, useMMKVString } from '..';
+const mmkv = createMMKV();
+beforeEach(() => {
+    mmkv.clearAll();
+    mmkv.trim();
+});
+test('hooks update when the value is changed directly through the instance', () => {
+    const { result } = renderHook(() => useMMKVString('string-key', mmkv));
+    expect(result.current[0]).toBeUndefined();
+    // First, make a "normal" change
+    act(() => {
+        result.current[1]('value 1');
+    });
+    expect(result.current[0]).toStrictEqual('value 1');
+    // Now, make the change directly through the instance.
+    act(() => {
+        mmkv.set('string-key', 'value 2');
+    });
+    expect(result.current[0]).toStrictEqual('value 2');
+});
+test('functional updates to hooks', () => {
+    const Component = () => {
+        const [state, setState] = React.useState(0);
+        const [value, setValue] = useMMKVNumber('number-key', mmkv);
+        return (React.createElement(React.Fragment, null,
+            React.createElement(Button, { testID: "button", title: "Double Increment Me", onPress: () => {
+                    // Increment the state value twice, using the function form of useState.
+                    setState((current) => current + 1);
+                    setState((current) => current + 1);
+                    // Increment the MMKV value twice, using the same function form.
+                    setValue((current) => (current ?? 0) + 1);
+                    setValue((current) => (current ?? 0) + 1);
+                } }),
+            React.createElement(Text, { testID: "state-value" },
+                "State: ",
+                state.toString()),
+            React.createElement(Text, { testID: "mmkv-value" },
+                "MMKV: ",
+                (value ?? 0).toString())));
+    };
+    render(React.createElement(Component, null));
+    const button = screen.getByTestId('button');
+    // Why these assertions:
+    // https://github.com/mrousavy/react-native-mmkv/issues/599
+    fireEvent.press(button);
+    expect(screen.getByTestId('state-value').children).toStrictEqual([
+        'State: ',
+        '2',
+    ]);
+    expect(screen.getByTestId('mmkv-value').children).toStrictEqual([
+        'MMKV: ',
+        '2',
+    ]);
+    fireEvent.press(button);
+    expect(screen.getByTestId('state-value').children).toStrictEqual([
+        'State: ',
+        '4',
+    ]);
+    expect(screen.getByTestId('mmkv-value').children).toStrictEqual([
+        'MMKV: ',
+        '4',
+    ]);
+});

package/lib/addMemoryWarningListener/addMemoryWarningListener.d.ts

@@ -0,0 +1,2 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+export declare function addMemoryWarningListener(mmkv: MMKV): void;

package/lib/addMemoryWarningListener/addMemoryWarningListener.js

@@ -0,0 +1,25 @@
+import { AppState } from 'react-native';
+export function addMemoryWarningListener(mmkv) {
+    if (global.WeakRef != null && global.FinalizationRegistry != null) {
+        // 1. Weakify MMKV so we can safely use it inside the memoryWarning event listener
+        const weakMmkv = new WeakRef(mmkv);
+        const listener = AppState.addEventListener('memoryWarning', () => {
+            // 0. Everytime we receive a memoryWarning, we try to trim the MMKV instance (if it is still valid)
+            weakMmkv.deref()?.trim();
+        });
+        // 2. Add a listener to when the MMKV instance is deleted
+        const finalization = new FinalizationRegistry((l) => {
+            // 3. When MMKV is deleted, this listener will be called with the memoryWarning listener.
+            l.remove();
+        });
+        // 2.1. Bind the listener to the actual MMKV instance.
+        finalization.register(mmkv, listener);
+    }
+    else {
+        // WeakRef/FinalizationRegistry is not implemented in this engine.
+        // Just add the listener, even if it retains MMKV strong forever.
+        AppState.addEventListener('memoryWarning', () => {
+            mmkv.trim();
+        });
+    }
+}

package/lib/addMemoryWarningListener/addMemoryWarningListener.mock.d.ts

@@ -0,0 +1,2 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+export declare function addMemoryWarningListener(_mmkv: MMKV): void;

package/lib/addMemoryWarningListener/addMemoryWarningListener.mock.js

@@ -0,0 +1,3 @@
+export function addMemoryWarningListener(_mmkv) {
+    // This is no-op in a mocked environment.
+}

package/lib/addMemoryWarningListener/addMemoryWarningListener.web.d.ts

@@ -0,0 +1,2 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+export declare const addMemoryWarningListener: (_mmkv: MMKV) => void;

package/lib/addMemoryWarningListener/addMemoryWarningListener.web.js

@@ -0,0 +1,3 @@
+export const addMemoryWarningListener = (_mmkv) => {
+    //no-op function, there is not a web equivalent to memory warning
+};

package/lib/createMMKV/createMMKV.d.ts

@@ -0,0 +1,3 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+import type { Configuration } from '../specs/MMKVFactory.nitro';
+export declare function createMMKV(configuration?: Configuration): MMKV;

package/lib/createMMKV/createMMKV.js

@@ -0,0 +1,40 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { Platform } from 'react-native';
+import { addMemoryWarningListener } from '../addMemoryWarningListener/addMemoryWarningListener';
+import { isTest } from '../isTest';
+import { createMockMMKV } from './createMMKV.mock';
+let factory;
+let platformContext;
+export function createMMKV(configuration) {
+    if (isTest()) {
+        // In a test environment, we mock the MMKV instance.
+        return createMockMMKV();
+    }
+    if (platformContext == null) {
+        // Lazy-init the platform-context HybridObject
+        platformContext = NitroModules.createHybridObject('MMKVPlatformContext');
+    }
+    if (factory == null) {
+        // Lazy-init the factory HybridObject
+        factory = NitroModules.createHybridObject('MMKVFactory');
+        const baseDirectory = platformContext.getBaseDirectory();
+        factory.initializeMMKV(baseDirectory);
+    }
+    // Pre-parse the config
+    let config = configuration ?? { id: factory.defaultMMKVInstanceId };
+    if (Platform.OS === 'ios') {
+        if (config.path == null) {
+            // If the user set an App Group directory in Info.plist, let's use
+            // the App Group as a MMKV path:
+            const appGroupDirectory = platformContext.getAppGroupDirectory();
+            if (appGroupDirectory != null) {
+                config.path = appGroupDirectory;
+            }
+        }
+    }
+    // Creates the C++ MMKV HybridObject
+    const mmkv = factory.createMMKV(config);
+    // Add a hook that trims the storage when we get a memory warning
+    addMemoryWarningListener(mmkv);
+    return mmkv;
+}

package/lib/createMMKV/createMMKV.mock.d.ts

@@ -0,0 +1,5 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+/**
+ * Mock MMKV instance when used in a Jest/Test environment.
+ */
+export declare function createMockMMKV(): MMKV;

package/lib/createMMKV/createMMKV.mock.js

@@ -0,0 +1,53 @@
+/**
+ * Mock MMKV instance when used in a Jest/Test environment.
+ */
+export function createMockMMKV() {
+    const storage = new Map();
+    const listeners = new Set();
+    return {
+        clearAll: () => storage.clear(),
+        remove: (key) => storage.delete(key),
+        set: (key, value) => storage.set(key, value),
+        getString: (key) => {
+            const result = storage.get(key);
+            return typeof result === 'string' ? result : undefined;
+        },
+        getNumber: (key) => {
+            const result = storage.get(key);
+            return typeof result === 'number' ? result : undefined;
+        },
+        getBoolean: (key) => {
+            const result = storage.get(key);
+            return typeof result === 'boolean' ? result : undefined;
+        },
+        getBuffer: (key) => {
+            const result = storage.get(key);
+            return result instanceof ArrayBuffer ? result : undefined;
+        },
+        getAllKeys: () => Array.from(storage.keys()),
+        contains: (key) => storage.has(key),
+        recrypt: () => {
+            console.warn('Encryption is not supported in mocked MMKV instances!');
+        },
+        get size() {
+            return storage.size;
+        },
+        isReadOnly: false,
+        trim: () => {
+            // no-op
+        },
+        name: 'MMKV',
+        dispose: () => { },
+        equals: () => {
+            return false;
+        },
+        addOnValueChangedListener: (listener) => {
+            listeners.add(listener);
+            return {
+                remove: () => {
+                    listeners.delete(listener);
+                },
+            };
+        },
+    };
+}

package/lib/createMMKV/createMMKV.web.d.ts

@@ -0,0 +1,3 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+import type { Configuration } from '../specs/MMKVFactory.nitro';
+export declare function createMMKV(config: Configuration): MMKV;