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

package/lib/hooks/useMMKVBoolean.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Use the boolean value of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * @example
+ * ```ts
+ * const [isPremiumAccount, setIsPremiumAccount] = useMMKVBoolean("user.isPremium")
+ * ```
+ */
+export declare const useMMKVBoolean: (key: string, instance?: import("..").MMKV) => [value: boolean | undefined, setValue: (value: boolean | ((current: boolean | undefined) => boolean | undefined) | undefined) => void];

package/lib/hooks/useMMKVBoolean.js

@@ -0,0 +1,12 @@
+import { createMMKVHook } from './createMMKVHook';
+/**
+ * Use the boolean value of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * @example
+ * ```ts
+ * const [isPremiumAccount, setIsPremiumAccount] = useMMKVBoolean("user.isPremium")
+ * ```
+ */
+export const useMMKVBoolean = createMMKVHook((instance, key) => instance.getBoolean(key));

package/lib/hooks/useMMKVBuffer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Use the buffer value (unsigned 8-bit (0-255)) of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * @example
+ * ```ts
+ * const [privateKey, setPrivateKey] = useMMKVBuffer("user.privateKey")
+ * ```
+ */
+export declare const useMMKVBuffer: (key: string, instance?: import("..").MMKV) => [value: ArrayBuffer | undefined, setValue: (value: ArrayBuffer | ((current: ArrayBuffer | undefined) => ArrayBuffer | undefined) | undefined) => void];

package/lib/hooks/useMMKVBuffer.js

@@ -0,0 +1,12 @@
+import { createMMKVHook } from './createMMKVHook';
+/**
+ * Use the buffer value (unsigned 8-bit (0-255)) of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * @example
+ * ```ts
+ * const [privateKey, setPrivateKey] = useMMKVBuffer("user.privateKey")
+ * ```
+ */
+export const useMMKVBuffer = createMMKVHook((instance, key) => instance.getBuffer(key));

package/lib/hooks/useMMKVKeys.d.ts

@@ -0,0 +1,12 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+/**
+ * Get a list of all keys that exist in the given MMKV {@linkcode instance}.
+ * The keys update when new keys are added or removed.
+ * @param instance The instance to listen to changes to (or the default instance)
+ *
+ * @example
+ * ```ts
+ * useMMKVKeys(instance)
+ * ```
+ */
+export declare function useMMKVKeys(instance?: MMKV): string[];

package/lib/hooks/useMMKVKeys.js

@@ -0,0 +1,33 @@
+import { useState } from 'react';
+import { getDefaultMMKVInstance } from '../createMMKV/getDefaultMMKVInstance';
+import { useMMKVListener } from './useMMKVListener';
+/**
+ * Get a list of all keys that exist in the given MMKV {@linkcode instance}.
+ * The keys update when new keys are added or removed.
+ * @param instance The instance to listen to changes to (or the default instance)
+ *
+ * @example
+ * ```ts
+ * useMMKVKeys(instance)
+ * ```
+ */
+export function useMMKVKeys(instance) {
+    const mmkv = instance ?? getDefaultMMKVInstance();
+    const [allKeys, setKeys] = useState(() => mmkv.getAllKeys());
+    useMMKVListener((key) => {
+        // a key changed
+        setKeys((keys) => {
+            const currentlyHasKey = keys.includes(key);
+            const hasKey = mmkv.contains(key);
+            if (hasKey !== currentlyHasKey) {
+                // Re-fetch the keys from native
+                return mmkv.getAllKeys();
+            }
+            else {
+                // We are up-to-date.
+                return keys;
+            }
+        });
+    }, mmkv);
+    return allKeys;
+}

package/lib/hooks/useMMKVListener.d.ts

@@ -0,0 +1,15 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+/**
+ * Listen for changes in the given MMKV storage instance.
+ * If no instance is passed, the default instance will be used.
+ * @param valueChangedListener The function to call whenever a value inside the storage instance changes
+ * @param instance The instance to listen to changes to (or the default instance)
+ *
+ * @example
+ * ```ts
+ * useMMKVListener((key) => {
+ *   console.log(`Value for "${key}" changed!`)
+ * })
+ * ```
+ */
+export declare function useMMKVListener(valueChangedListener: (key: string) => void, instance?: MMKV): void;

package/lib/hooks/useMMKVListener.js

@@ -0,0 +1,26 @@
+import { useEffect, useRef } from 'react';
+import { getDefaultMMKVInstance } from '../createMMKV/getDefaultMMKVInstance';
+/**
+ * Listen for changes in the given MMKV storage instance.
+ * If no instance is passed, the default instance will be used.
+ * @param valueChangedListener The function to call whenever a value inside the storage instance changes
+ * @param instance The instance to listen to changes to (or the default instance)
+ *
+ * @example
+ * ```ts
+ * useMMKVListener((key) => {
+ *   console.log(`Value for "${key}" changed!`)
+ * })
+ * ```
+ */
+export function useMMKVListener(valueChangedListener, instance) {
+    const ref = useRef(valueChangedListener);
+    ref.current = valueChangedListener;
+    const mmkv = instance ?? getDefaultMMKVInstance();
+    useEffect(() => {
+        const listener = mmkv.addOnValueChangedListener((changedKey) => {
+            ref.current(changedKey);
+        });
+        return () => listener.remove();
+    }, [mmkv]);
+}

package/lib/hooks/useMMKVNumber.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Use the number value of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * @example
+ * ```ts
+ * const [age, setAge] = useMMKVNumber("user.age")
+ * ```
+ */
+export declare const useMMKVNumber: (key: string, instance?: import("..").MMKV) => [value: number | undefined, setValue: (value: number | ((current: number | undefined) => number | undefined) | undefined) => void];

package/lib/hooks/useMMKVNumber.js

@@ -0,0 +1,12 @@
+import { createMMKVHook } from './createMMKVHook';
+/**
+ * Use the number value of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * @example
+ * ```ts
+ * const [age, setAge] = useMMKVNumber("user.age")
+ * ```
+ */
+export const useMMKVNumber = createMMKVHook((instance, key) => instance.getNumber(key));

package/lib/hooks/useMMKVObject.d.ts

@@ -0,0 +1,17 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+/**
+ * Use an object value of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * The object will be serialized using `JSON`.
+ *
+ * @example
+ * ```ts
+ * const [user, setUser] = useMMKVObject<User>("user")
+ * ```
+ */
+export declare function useMMKVObject<T>(key: string, instance?: MMKV): [
+    value: T | undefined,
+    setValue: (value: T | undefined | ((prevValue: T | undefined) => T | undefined)) => void
+];

package/lib/hooks/useMMKVObject.js

@@ -0,0 +1,38 @@
+import { useCallback, useMemo } from 'react';
+import { useMMKVString } from './useMMKVString';
+/**
+ * Use an object value of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * The object will be serialized using `JSON`.
+ *
+ * @example
+ * ```ts
+ * const [user, setUser] = useMMKVObject<User>("user")
+ * ```
+ */
+export function useMMKVObject(key, instance) {
+    const [json, setJson] = useMMKVString(key, instance);
+    const value = useMemo(() => {
+        if (json == null)
+            return undefined;
+        return JSON.parse(json);
+    }, [json]);
+    const setValue = useCallback((v) => {
+        if (v instanceof Function) {
+            setJson((currentJson) => {
+                const currentValue = currentJson != null ? JSON.parse(currentJson) : undefined;
+                const newValue = v(currentValue);
+                // Store the Object as a serialized Value or clear the value
+                return newValue != null ? JSON.stringify(newValue) : undefined;
+            });
+        }
+        else {
+            // Store the Object as a serialized Value or clear the value
+            const newValue = v != null ? JSON.stringify(v) : undefined;
+            setJson(newValue);
+        }
+    }, [setJson]);
+    return [value, setValue];
+}

package/lib/hooks/useMMKVString.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Use the string value of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * @example
+ * ```ts
+ * const [username, setUsername] = useMMKVString("user.name")
+ * ```
+ */
+export declare const useMMKVString: (key: string, instance?: import("..").MMKV) => [value: string | undefined, setValue: (value: string | ((current: string | undefined) => string | undefined) | undefined) => void];

package/lib/hooks/useMMKVString.js

@@ -0,0 +1,12 @@
+import { createMMKVHook } from './createMMKVHook';
+/**
+ * Use the string value of the given `key` from the given MMKV storage instance.
+ *
+ * If no instance is provided, a shared default instance will be used.
+ *
+ * @example
+ * ```ts
+ * const [username, setUsername] = useMMKVString("user.name")
+ * ```
+ */
+export const useMMKVString = createMMKVHook((instance, key) => instance.getString(key));

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export type { MMKV } from './specs/MMKV.nitro';
+export type { Configuration, Mode } from './specs/MMKVFactory.nitro';
+export { createMMKV } from './createMMKV/createMMKV';
+export { useMMKV } from './hooks/useMMKV';
+export { useMMKVBoolean } from './hooks/useMMKVBoolean';
+export { useMMKVBuffer } from './hooks/useMMKVBuffer';
+export { useMMKVNumber } from './hooks/useMMKVNumber';
+export { useMMKVObject } from './hooks/useMMKVObject';
+export { useMMKVString } from './hooks/useMMKVString';
+export { useMMKVListener } from './hooks/useMMKVListener';
+export { useMMKVKeys } from './hooks/useMMKVKeys';

package/lib/index.js

@@ -0,0 +1,11 @@
+// The create function
+export { createMMKV } from './createMMKV/createMMKV';
+// All the hooks
+export { useMMKV } from './hooks/useMMKV';
+export { useMMKVBoolean } from './hooks/useMMKVBoolean';
+export { useMMKVBuffer } from './hooks/useMMKVBuffer';
+export { useMMKVNumber } from './hooks/useMMKVNumber';
+export { useMMKVObject } from './hooks/useMMKVObject';
+export { useMMKVString } from './hooks/useMMKVString';
+export { useMMKVListener } from './hooks/useMMKVListener';
+export { useMMKVKeys } from './hooks/useMMKVKeys';

package/lib/isTest.d.ts

@@ -0,0 +1 @@
+export declare function isTest(): boolean;

package/lib/isTest.js

@@ -0,0 +1,7 @@
+export function isTest() {
+    if (global.process == null) {
+        // In a WebBrowser/Electron the `process` variable does not exist
+        return false;
+    }
+    return (process.env.JEST_WORKER_ID != null || process.env.VITEST_WORKER_ID != null);
+}

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

@@ -0,0 +1,94 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface Listener {
+    remove: () => void;
+}
+export interface MMKV extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    /**
+     * Set a value for the given `key`.
+     *
+     * @throws an Error if the value cannot be set.
+     */
+    set(key: string, value: boolean | string | number | ArrayBuffer): void;
+    /**
+     * Get the boolean value for the given `key`, or `undefined` if it does not exist.
+     *
+     * @default undefined
+     */
+    getBoolean(key: string): boolean | undefined;
+    /**
+     * Get the string value for the given `key`, or `undefined` if it does not exist.
+     *
+     * @default undefined
+     */
+    getString(key: string): string | undefined;
+    /**
+     * Get the number value for the given `key`, or `undefined` if it does not exist.
+     *
+     * @default undefined
+     */
+    getNumber(key: string): number | undefined;
+    /**
+     * Get a raw buffer of unsigned 8-bit (0-255) data.
+     *
+     * @default undefined
+     */
+    getBuffer(key: string): ArrayBuffer | undefined;
+    /**
+     * Checks whether the given `key` is being stored in this MMKV instance.
+     */
+    contains(key: string): boolean;
+    /**
+     * Removes the given `key`.
+     * @returns true if the key was removed, false otherwise
+     */
+    remove(key: string): boolean;
+    /**
+     * Get all keys.
+     *
+     * @default []
+     */
+    getAllKeys(): string[];
+    /**
+     * Clears all keys/values.
+     */
+    clearAll(): void;
+    /**
+     * Sets (or updates) the encryption-key to encrypt all data in this MMKV instance with.
+     *
+     * To remove encryption, pass `undefined` as a key.
+     *
+     * Encryption keys can have a maximum length of 16 bytes.
+     *
+     * @throws an Error if the instance cannot be recrypted.
+     */
+    recrypt(key: string | undefined): void;
+    /**
+     * Trims the storage space and clears memory cache.
+     *
+     * Since MMKV does not resize itself after deleting keys, you can call `trim()`
+     * after deleting a bunch of keys to manually trim the memory- and
+     * disk-file to reduce storage and memory usage.
+     *
+     * In most applications, this is not needed at all.
+     */
+    trim(): void;
+    /**
+     * Get the current total size of the storage, in bytes.
+     */
+    readonly size: number;
+    /**
+     * Returns whether this instance is in read-only mode or not.
+     * If this is `true`, you can only use "get"-functions.
+     */
+    readonly isReadOnly: boolean;
+    /**
+     * Adds a value changed listener. The Listener will be called whenever any value
+     * in this storage instance changes (set or delete).
+     *
+     * To unsubscribe from value changes, call `remove()` on the Listener.
+     */
+    addOnValueChangedListener(onValueChanged: (key: string) => void): Listener;
+}

package/lib/specs/MMKV.nitro.js

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

package/lib/{typescript/src/NativeMmkv.d.ts → specs/MMKVFactory.nitro.d.ts}

@@ -1,23 +1,11 @@
-import type { TurboModule } from 'react-native';
-import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
-/**
- * IMPORTANT: These types are also in the Types.ts file.
- * Due to how react-native-codegen works these are required here as the spec types can not be separated from spec.
- * We also need the types separate to allow bypassing importing turbo module registry in web
- */
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { MMKV } from './MMKV.nitro';
 /**
  * Configures the mode of the MMKV instance.
+ * - `single-process`: The MMKV instance is only used from a single process (this app).
+ * - `multi-process`: The MMKV instance may be used from multiple processes, such as app clips, share extensions or background services.
  */
-export declare enum Mode {
-    /**
-     * The MMKV instance is only used from a single process (this app).
-     */
-    SINGLE_PROCESS = 0,
-    /**
-     * The MMKV instance may be used from multiple processes, such as app clips, share extensions or background services.
-     */
-    MULTI_PROCESS = 1
-}
+export type Mode = 'single-process' | 'multi-process';
 /**
  * Used for configuration of a single MMKV instance.
  */
@@ -27,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'
@@ -39,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.
@@ -56,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
@@ -64,28 +52,33 @@ export interface Configuration {
     encryptionKey?: string;
     /**
      * Configure the processing mode for MMKV.
-     * - `SINGLE_PROCESS`: The MMKV instance is only used from a single process (this app).
-     * - `MULTI_PROCESS`: The MMKV instance may be used from multiple processes, such as app clips, share extensions or background services.
      *
-     * @default SINGLE_PROCESS
+     * @default 'single-process'
      */
     mode?: Mode;
     /**
      * If `true`, the MMKV instance can only read from the storage, but not write to it.
+     * This is more efficient if you do not need to write to it.
+     * @default false
      */
     readOnly?: boolean;
 }
-export interface Spec extends TurboModule {
+export interface MMKVFactory extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
     /**
-     * Initialize MMKV with the given base storage directory.
-     * This should be the documents directory by default.
+     * Create a new {@linkcode MMKV} instance with the given {@linkcode Configuration}
      */
-    initialize(basePath: string): boolean;
+    createMMKV(configuration: Configuration): MMKV;
     /**
-     * Create a new instance of MMKV.
-     * The returned {@linkcode UnsafeObject} is a `jsi::HostObject`.
+     * Initialize the MMKV library with the given root path.
+     * This has to be called once, before using {@linkcode createMMKV}.
+     */
+    initializeMMKV(rootPath: string): void;
+    /**
+     * Get the default MMKV instance's ID.
+     * @default 'mmkv.default'
      */
-    createMMKV(configuration: Configuration): UnsafeObject;
+    readonly defaultMMKVInstanceId: string;
 }
-export declare function getMMKVTurboModule(): Spec;
-//# sourceMappingURL=NativeMmkv.d.ts.map

package/lib/specs/MMKVFactory.nitro.js

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

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

@@ -0,0 +1,18 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface MMKVPlatformContext extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Get the MMKV base directory
+     */
+    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 | undefined;
+}

package/lib/specs/MMKVPlatformContext.nitro.js

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

package/lib/{typescript/src → web}/createTextEncoder.d.ts

@@ -1,2 +1 @@
 export declare function createTextEncoder(): TextEncoder;
-//# sourceMappingURL=createTextEncoder.d.ts.map

package/lib/web/createTextEncoder.js

@@ -0,0 +1,17 @@
+export function createTextEncoder() {
+    const g = global ?? globalThis ?? window;
+    if (g.TextEncoder != null) {
+        return new g.TextEncoder();
+    }
+    else {
+        return {
+            encode: () => {
+                throw new Error('TextEncoder is not supported in this environment!');
+            },
+            encodeInto: () => {
+                throw new Error('TextEncoder is not supported in this environment!');
+            },
+            encoding: 'utf-8',
+        };
+    }
+}

package/nitro.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": [
+    "mmkv"
+  ],
+  "ios": {
+    "iosModuleName": "NitroMmkv"
+  },
+  "android": {
+    "androidNamespace": [
+      "mmkv"
+    ],
+    "androidCxxLibName": "NitroMmkv"
+  },
+  "autolinking": {
+    "MMKVFactory": {
+      "cpp": "HybridMMKVFactory"
+    },
+    "MMKVPlatformContext": {
+      "swift": "HybridMMKVPlatformContext",
+      "kotlin": "HybridMMKVPlatformContext"
+    }
+  },
+  "ignorePaths": [
+    "**/node_modules"
+  ],
+  "gitAttributesGeneratedFlag": false
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=false

package/nitrogen/generated/android/NitroMmkv+autolinking.cmake

@@ -0,0 +1,80 @@
+#
+# NitroMmkv+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © 2025 Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroMmkv+autolinking.cmake)
+# ```
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  NitroMmkv PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NitroMmkvOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridMMKVSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMMKVFactorySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMMKVPlatformContextSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridMMKVPlatformContextSpec.cpp
+)
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NITROMMKV_WITH_GENERATED_CMAKE_PROJECT)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+ target_compile_definitions(
+  NitroMmkv PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        NitroMmkv
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        NitroMmkv
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NitroMmkv
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()