react-native-mmkv 4.1.2 → 4.3.0

package/src/createMMKV/createMMKV.web.ts

@@ -39,8 +39,18 @@ export function createMMKV(
 
   return {
     id: config.id,
-    size: 0,
+    get length(): number {
+      return getLocalStorage().length
+    },
+    get size(): number {
+      return this.byteSize
+    },
+    get byteSize(): number {
+      // estimate - assumes UTF8
+      return JSON.stringify(getLocalStorage()).length
+    },
     isReadOnly: false,
+    isEncrypted: false,
     clearAll: () => {
       const storage = getLocalStorage()
       const keys = Object.keys(storage)
@@ -100,6 +110,12 @@ export function createMMKV(
     recrypt: () => {
       throw new Error('`recrypt(..)` is not supported on Web!')
     },
+    encrypt: () => {
+      throw new Error('`encrypt(..)` is not supported on Web!')
+    },
+    decrypt: () => {
+      throw new Error('`decrypt(..)` is not supported on Web!')
+    },
     trim: () => {
       // no-op
     },

package/src/createMMKV/createMockMMKV.ts

@@ -18,10 +18,18 @@ export function createMockMMKV(
 
   return {
     id: config.id,
-    get size(): number {
+    get length(): number {
       return storage.size
     },
+    get size(): number {
+      return this.byteSize
+    },
+    get byteSize(): number {
+      // estimate - assumes UTF8
+      return JSON.stringify(storage).length
+    },
     isReadOnly: false,
+    isEncrypted: false,
     clearAll: () => {
       const keysBefore = storage.keys()
       storage.clear()
@@ -63,6 +71,12 @@ export function createMockMMKV(
     recrypt: () => {
       console.warn('Encryption is not supported in mocked MMKV instances!')
     },
+    encrypt: () => {
+      console.warn('Encryption is not supported in mocked MMKV instances!')
+    },
+    decrypt: () => {
+      console.warn('Encryption is not supported in mocked MMKV instances!')
+    },
     trim: () => {
       // no-op
     },

package/src/hooks/createMMKVHook.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
+import { useCallback, useSyncExternalStore } from 'react'
 import { getDefaultMMKVInstance } from '../createMMKV/getDefaultMMKVInstance'
 import type { MMKV } from '../specs/MMKV.nitro'
 
@@ -13,14 +13,21 @@ export function createMMKVHook<
   ): [value: T, setValue: (value: TSetAction) => void] => {
     const mmkv = instance ?? getDefaultMMKVInstance()
 
-    const [bump, setBump] = useState(0)
-    const value = useMemo(() => {
-      // bump is here as an additional outside dependency, so this useMemo
-      // re-computes the value each time bump changes, effectively acting as a hint
-      // that the outside value (storage) has changed. setting bump refreshes this value.
-      bump
-      return getter(mmkv, key)
-    }, [mmkv, key, bump])
+    const value = useSyncExternalStore(
+      useCallback(
+        (onStoreChange: () => void) => {
+          const listener = mmkv.addOnValueChangedListener((changedKey) => {
+            if (changedKey === key) {
+              onStoreChange()
+            }
+          })
+          return () => listener.remove()
+        },
+        [key, mmkv]
+      ),
+      useCallback(() => getter(mmkv, key), [key, mmkv]),
+      useCallback(() => getter(mmkv, key), [key, mmkv])
+    )
 
     // update value by user set
     const set = useCallback(
@@ -51,16 +58,6 @@ export function createMMKVHook<
       [key, mmkv]
     )
 
-    // update value if it changes somewhere else (second hook, same key)
-    useEffect(() => {
-      const listener = mmkv.addOnValueChangedListener((changedKey) => {
-        if (changedKey === key) {
-          setBump((b) => b + 1)
-        }
-      })
-      return () => listener.remove()
-    }, [key, mmkv])
-
     return [value, set]
   }
 }

package/src/specs/MMKV.nitro.ts

@@ -1,4 +1,5 @@
 import type { HybridObject } from 'react-native-nitro-modules'
+import type { EncryptionType } from './MMKVFactory.nitro'
 
 export interface Listener {
   remove: () => void
@@ -9,15 +10,31 @@ export interface MMKV extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
    * Get the ID of this {@linkcode MMKV} instance.
    */
   readonly id: string
+  /**
+   * Get the current amount of key/value pairs stored in
+   * this storage.
+   */
+  readonly length: number
   /**
    * Get the current total size of the storage, in bytes.
+   * @deprecated Use {@linkcode byteSize} instead.
    */
   readonly size: number
   /**
-   * Returns whether this instance is in read-only mode or not.
+   * Get the current total size of the storage, in bytes.
+   */
+  readonly byteSize: number
+  /**
+   * Get whether this instance is in read-only mode or not.
    * If this is `true`, you can only use "get"-functions.
    */
   readonly isReadOnly: boolean
+  /**
+   * Get whether this instance is encrypted, or not.
+   * @see {@linkcode encrypt | encrypt(...)}
+   * @see {@linkcode decrypt | decrypt()}
+   */
+  readonly isEncrypted: boolean
   /**
    * Set a {@linkcode value} for the given {@linkcode key}.
    *
@@ -76,8 +93,36 @@ export interface MMKV extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
    * Encryption keys can have a maximum length of 16 bytes.
    *
    * @throws an Error if the instance cannot be recrypted.
+   * @deprecated Use {@linkcode encrypt | encrypt(...)} or {@linkcode decrypt | decrypt()} instead.
    */
   recrypt(key: string | undefined): void
+  /**
+   * Encrypts the data in this MMKV instance with the
+   * given {@linkcode key} and {@linkcode encryptionType}.
+   *
+   * If this MMKV instance is already encrypted ({@linkcode isEncrypted}),
+   * it will re-encrypt the data.
+   *
+   * Future attempts to open this MMKV instance will require the same
+   * {@linkcode key} and {@linkcode encryptionType}, otherwise reads
+   * will fail.
+   *
+   * The {@linkcode key} must be 16-bytes in {@linkcode EncryptionType | 'AES-128'}
+   * encryption (the default), or 32-bytes in {@linkcode EncryptionType | 'AES-256'}
+   * encryption.
+   *
+   * @param key The encryption key to use. In AES-128 this must be 16-bytes, in AES-256 it must be 32-bytes long.
+   * @param encryptionType The encryption type to use. Default: AES-128
+   */
+  encrypt(key: string, encryptionType?: EncryptionType): void
+  /**
+   * Decrypts the data in this MMKV instance and removes
+   * the encryption key.
+   *
+   * Future attempts to open this MMKV instance must be done
+   * without an encryption key, as it is now plain-text.
+   */
+  decrypt(): void
   /**
    * Trims the storage space and clears memory cache.
    *

package/src/specs/MMKVFactory.nitro.ts

@@ -8,6 +8,13 @@ import type { MMKV } from './MMKV.nitro'
  */
 export type Mode = 'single-process' | 'multi-process'
 
+/**
+ * Configures the encryption algorithm for the MMKV instance.
+ * - `AES-128`: Uses AES-128 encryption (default).
+ * - `AES-256`: Uses AES-256 encryption for enhanced security.
+ */
+export type EncryptionType = 'AES-128' | 'AES-256'
+
 /**
  * Used for configuration of a single MMKV instance.
  */
@@ -42,7 +49,7 @@ export interface Configuration {
   /**
    * The MMKV instance's encryption/decryption key. By default, MMKV stores all key-values in plain text on file, relying on iOS's sandbox to make sure the file is encrypted. Should you worry about information leaking, you can choose to encrypt MMKV.
    *
-   * Encryption keys can have a maximum length of 16 bytes.
+   * Encryption keys can have a maximum length of 16 bytes with AES-128 encryption and 32 bytes with AES-256 encryption.
    *
    * @example
    * ```ts
@@ -52,6 +59,21 @@ export interface Configuration {
    * @default undefined
    */
   encryptionKey?: string
+  /**
+   * The encryption algorithm to use when an encryption key is provided.
+   *
+   * @example
+   * ```ts
+   * const secureStorage = createMMKV({
+   *   id: 'secure-storage',
+   *   encryptionKey: 'my-encryption-key!',
+   *   encryptionType: 'AES-256'
+   * })
+   * ```
+   *
+   * @default 'AES-128'
+   */
+  encryptionType?: EncryptionType
   /**
    * Configure the processing mode for MMKV.
    *
@@ -64,6 +86,14 @@ export interface Configuration {
    * @default false
    */
   readOnly?: boolean
+  /**
+   * If `true`, MMKV will internally compare a value for equality before writing to
+   * disk, and if the new value is equal to what is already stored, it will skip
+   * the file write.
+   * Treat this as an optional performance optimization.
+   * @default false
+   */
+  compareBeforeSet?: boolean
 }
 
 export interface MMKVFactory