chore: upgrade to react-native-mmkv v4

__mocks__/react-native-mmkv.js

@@ -1,20 +1,25 @@
 // Mock for react-native-mmkv
-const { useState, useEffect } = require('react');
+const { useState, useEffect, useRef, useMemo, useCallback } = require('react');
 
 // Shared storage between instances with the same id
 const storageInstances = new Map();
+let defaultInstance = null;
 
 export const Mode = {
-	SINGLE_PROCESS: 1,
-	MULTI_PROCESS: 2
+	SINGLE_PROCESS: 'single-process',
+	MULTI_PROCESS: 'multi-process'
 };
 
-export class MMKV {
+// MMKV Instance class
+class MMKVInstance {
 	constructor(config = {}) {
-		const { id = 'default', mode, path } = config;
+		const { id = 'mmkv.default', path, encryptionKey, mode, readOnly } = config;
 		this.id = id;
-		this.mode = mode;
 		this.path = path;
+		this.encryptionKey = encryptionKey;
+		this.mode = mode;
+		this.isReadOnly = readOnly || false;
+		this._size = 0;
 
 		// Share storage between instances with the same id
 		if (!storageInstances.has(this.id)) {
@@ -29,8 +34,16 @@ export class MMKV {
 		this.listeners = instance.listeners;
 	}
 
+	get size() {
+		return this._size;
+	}
+
 	set(key, value) {
+		if (this.isReadOnly) {
+			throw new Error('Cannot set value in read-only instance');
+		}
 		this.storage.set(key, value);
+		this._size = this.storage.size;
 		this.notifyListeners(key);
 	}
 
@@ -49,13 +62,22 @@ export class MMKV {
 		return typeof value === 'boolean' ? value : undefined;
 	}
 
+	getBuffer(key) {
+		const value = this.storage.get(key);
+		return value instanceof ArrayBuffer ? value : undefined;
+	}
+
 	contains(key) {
 		return this.storage.has(key);
 	}
 
-	delete(key) {
+	remove(key) {
+		if (this.isReadOnly) {
+			throw new Error('Cannot remove value in read-only instance');
+		}
 		const deleted = this.storage.delete(key);
 		if (deleted) {
+			this._size = this.storage.size;
 			this.notifyListeners(key);
 		}
 		return deleted;
@@ -66,11 +88,39 @@ export class MMKV {
 	}
 
 	clearAll() {
+		if (this.isReadOnly) {
+			throw new Error('Cannot clear read-only instance');
+		}
 		this.storage.clear();
+		this._size = 0;
 		// Notify about clear (pass undefined to indicate clear all)
 		this.notifyListeners(undefined);
 	}
 
+	recrypt(key) {
+		this.encryptionKey = key;
+	}
+
+	trim() {
+		// No-op for mock
+	}
+
+	importAllFrom(other) {
+		if (this.isReadOnly) {
+			throw new Error('Cannot import values into read-only instance');
+		}
+		let count = 0;
+		for (const [key, value] of other.storage.entries()) {
+			this.storage.set(key, value);
+			count++;
+		}
+		this._size = this.storage.size;
+		if (count > 0) {
+			this.notifyListeners(undefined);
+		}
+		return count;
+	}
+
 	addOnValueChangedListener(callback) {
 		this.listeners.push(callback);
 		return {
@@ -94,106 +144,202 @@ export class MMKV {
 	}
 }
 
-// Export Configuration type for TypeScript
-export const Configuration = {};
+// Factory function to create MMKV instances
+export function createMMKV(configuration) {
+	return new MMKVInstance(configuration);
+}
 
-// React hooks for MMKV
-export function useMMKVString(key, mmkvInstance) {
-	const [value, setValue] = useState(() => mmkvInstance.getString(key));
+// Get default instance
+function getDefaultMMKVInstance() {
+	if (defaultInstance == null) {
+		defaultInstance = createMMKV();
+	}
+	return defaultInstance;
+}
 
-	useEffect(() => {
-		const listener = mmkvInstance.addOnValueChangedListener(changedKey => {
-			if (changedKey === key || changedKey === undefined) {
-				setValue(mmkvInstance.getString(key));
-			}
-		});
-		return () => listener.remove();
-	}, [key, mmkvInstance]);
+// Top-level functions
+export function existsMMKV(id) {
+	return storageInstances.has(id);
+}
 
-	const setStoredValue = newValue => {
-		if (newValue === undefined) {
-			mmkvInstance.delete(key);
-		} else {
-			mmkvInstance.set(key, newValue);
-		}
-		setValue(newValue);
-	};
+export function deleteMMKV(id) {
+	const instance = storageInstances.get(id);
+	instance?.storage.clear();
+	instance?.listeners.splice(0);
 
-	return [value, setStoredValue];
+	const deleted = storageInstances.delete(id);
+	if (defaultInstance?.id === id) {
+		defaultInstance = null;
+	}
+	return deleted;
 }
 
-export function useMMKVNumber(key, mmkvInstance) {
-	const [value, setValue] = useState(() => mmkvInstance.getNumber(key));
+// Helper function for configuration comparison
+function isConfigurationEqual(left, right) {
+	if (left == null || right == null) {
+		return left == null && right == null;
+	}
 
-	useEffect(() => {
-		const listener = mmkvInstance.addOnValueChangedListener(changedKey => {
-			if (changedKey === key || changedKey === undefined) {
-				setValue(mmkvInstance.getNumber(key));
-			}
-		});
-		return () => listener.remove();
-	}, [key, mmkvInstance]);
+	return (
+		left.encryptionKey === right.encryptionKey &&
+		left.id === right.id &&
+		left.path === right.path &&
+		left.mode === right.mode &&
+		left.readOnly === right.readOnly
+	);
+}
 
-	const setStoredValue = newValue => {
-		if (newValue === undefined) {
-			mmkvInstance.delete(key);
-		} else {
-			mmkvInstance.set(key, newValue);
-		}
-		setValue(newValue);
-	};
+/**
+ * Use the default, shared MMKV instance or a custom instance with configuration
+ */
+export function useMMKV(configuration) {
+	const configurationRef = useRef();
+	const instanceRef = useRef();
 
-	return [value, setStoredValue];
+	if (configuration == null) {
+		return getDefaultMMKVInstance();
+	}
+
+	if (!instanceRef.current || !isConfigurationEqual(configurationRef.current, configuration)) {
+		configurationRef.current = configuration;
+		instanceRef.current = createMMKV(configuration);
+	}
+
+	return instanceRef.current;
 }
 
-export function useMMKVBoolean(key, mmkvInstance) {
-	const [value, setValue] = useState(() => mmkvInstance.getBoolean(key));
+/**
+ * Listen for changes in the given MMKV storage instance
+ */
+export function useMMKVListener(valueChangedListener, instance) {
+	const ref = useRef(valueChangedListener);
+	const mmkv = instance ?? getDefaultMMKVInstance();
 
 	useEffect(() => {
-		const listener = mmkvInstance.addOnValueChangedListener(changedKey => {
-			if (changedKey === key || changedKey === undefined) {
-				setValue(mmkvInstance.getBoolean(key));
-			}
+		ref.current = valueChangedListener;
+	}, [valueChangedListener]);
+
+	useEffect(() => {
+		const listener = mmkv.addOnValueChangedListener(changedKey => {
+			ref.current(changedKey);
 		});
 		return () => listener.remove();
-	}, [key, mmkvInstance]);
+	}, [mmkv]);
+}
+
+/**
+ * Get a list of all keys that exist in the given MMKV instance
+ */
+export function useMMKVKeys(instance) {
+	const mmkv = instance ?? getDefaultMMKVInstance();
+	const [allKeys, setKeys] = useState(() => mmkv.getAllKeys());
 
-	const setStoredValue = newValue => {
-		if (newValue === undefined) {
-			mmkvInstance.delete(key);
-		} else {
-			mmkvInstance.set(key, newValue);
+	useEffect(() => {
+		setKeys(mmkv.getAllKeys());
+	}, [mmkv]);
+
+	useMMKVListener(key => {
+		if (key === undefined) {
+			setKeys(() => mmkv.getAllKeys());
+			return;
 		}
-		setValue(newValue);
-	};
 
-	return [value, setStoredValue];
+		const currentlyHasKey = allKeys.includes(key);
+		const hasKey = mmkv.contains(key);
+		if (hasKey !== currentlyHasKey) {
+			setKeys(() => mmkv.getAllKeys());
+		}
+	}, mmkv);
+
+	return allKeys;
 }
 
-export function useMMKVObject(key, mmkvInstance) {
-	const [value, setValue] = useState(() => {
-		const stored = mmkvInstance.getString(key);
-		return stored ? JSON.parse(stored) : undefined;
-	});
+/**
+ * Create a custom MMKV hook for a specific type
+ */
+function createMMKVHook(getter, onSet) {
+	return (key, instance) => {
+		const mmkv = instance ?? getDefaultMMKVInstance();
+
+		const [bump, setBump] = useState(0);
+		const value = useMemo(() => getter(mmkv, key), [mmkv, key, bump]);
+
+		const set = useCallback(
+			v => {
+				const newValue = typeof v === 'function' ? v(getter(mmkv, key)) : v;
+				if (onSet) {
+					onSet(mmkv, key, newValue);
+					return;
+				}
+				switch (typeof newValue) {
+					case 'number':
+					case 'string':
+					case 'boolean':
+						mmkv.set(key, newValue);
+						break;
+					case 'undefined':
+						mmkv.remove(key);
+						break;
+					case 'object':
+						if (newValue instanceof ArrayBuffer) {
+							mmkv.set(key, newValue);
+							break;
+						} else {
+							throw new Error(`MMKV: Type object (${newValue}) is not supported!`);
+						}
+					default:
+						throw new Error(`MMKV: Type ${typeof newValue} is not supported!`);
+				}
+			},
+			[key, mmkv, onSet]
+		);
+
+		useEffect(() => {
+			const listener = mmkv.addOnValueChangedListener(changedKey => {
+				if (changedKey === undefined || changedKey === key) {
+					setBump(b => b + 1);
+				}
+			});
+			return () => listener.remove();
+		}, [key, mmkv]);
 
-	useEffect(() => {
-		const listener = mmkvInstance.addOnValueChangedListener(changedKey => {
-			if (changedKey === key || changedKey === undefined) {
-				const stored = mmkvInstance.getString(key);
-				setValue(stored ? JSON.parse(stored) : undefined);
-			}
-		});
-		return () => listener.remove();
-	}, [key, mmkvInstance]);
+		return [value, set];
+	};
+}
 
-	const setStoredValue = newValue => {
-		if (newValue === undefined) {
-			mmkvInstance.delete(key);
-		} else {
-			mmkvInstance.set(key, JSON.stringify(newValue));
+/**
+ * Use the string value of the given key from the given MMKV storage instance
+ */
+export const useMMKVString = createMMKVHook((instance, key) => instance.getString(key));
+
+/**
+ * Use the number value of the given key from the given MMKV storage instance
+ */
+export const useMMKVNumber = createMMKVHook((instance, key) => instance.getNumber(key));
+
+/**
+ * Use the boolean value of the given key from the given MMKV storage instance
+ */
+export const useMMKVBoolean = createMMKVHook((instance, key) => instance.getBoolean(key));
+
+/**
+ * Use the object value (JSON stringified) of the given key from the given MMKV storage instance
+ */
+export const useMMKVObject = createMMKVHook(
+	(instance, key) => {
+		const stored = instance.getString(key);
+		return stored ? JSON.parse(stored) : undefined;
+	},
+	(mmkv, key, value) => {
+		if (value === undefined) {
+			mmkv.remove(key);
+			return;
 		}
-		setValue(newValue);
-	};
+		mmkv.set(key, JSON.stringify(value));
+	}
+);
 
-	return [value, setStoredValue];
-}
+/**
+ * Use the buffer value of the given key from the given MMKV storage instance
+ */
+export const useMMKVBuffer = createMMKVHook((instance, key) => instance.getBuffer(key));