@onekeyfe/react-native-async-storage 3.0.76 → 3.0.78

package/android/src/main/java/com/asyncstorage/RNCAsyncStorageModule.kt

@@ -292,6 +292,10 @@ class RNCAsyncStorageModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    override fun reloadManifest(promise: Promise) {
+        promise.resolve(null)
+    }
+
     // --- Private helpers (ported from AsyncLocalStorageUtil.java) ---
 
     private fun ensureDatabase(): Boolean {

package/ios/AsyncStorage.h

@@ -24,4 +24,7 @@
 - (void)clear:(RCTPromiseResolveBlock)resolve
        reject:(RCTPromiseRejectBlock)reject;
 
+- (void)reloadManifest:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject;
+
 @end

package/ios/AsyncStorage.mm

@@ -711,4 +711,20 @@ static void RCTStorageDirectoryMigrationCheck(NSString *fromStorageDirectory,
     });
 }
 
+- (void)reloadManifest:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject
+{
+    dispatch_async(RCTGetMethodQueue(), ^{
+        self->_haveSetup = NO;
+        NSDictionary *ensureSetupError = [self _ensureSetup];
+        if (ensureSetupError) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   ensureSetupError[@"message"] ?: @"Storage setup failed",
+                   nil);
+            return;
+        }
+        resolve(nil);
+    });
+}
+
 @end

package/lib/module/NativeAsyncStorage.web.js

@@ -135,7 +135,8 @@ const AsyncStorage = {
   multiMerge: (keyValuePairs, callback) => {
     const promises = keyValuePairs.map(item => AsyncStorage.mergeItem(item[0], item[1]));
     return createPromiseAll(promises, callback);
-  }
+  },
+  reloadManifest: () => Promise.resolve()
 };
 export default AsyncStorage;
 //# sourceMappingURL=NativeAsyncStorage.web.js.map

package/lib/module/index.js

@@ -1,11 +1,45 @@
 "use strict";
 
 import NativeModule from './NativeAsyncStorage';
-import { forwardAsyncStorageWriteIfNeeded } from "./runtimeConfig.js";
+import { forwardAsyncStorageWrite, forwardAsyncStorageWriteIfNeeded, shouldForwardAsyncStorageWrite } from "./runtimeConfig.js";
+async function forwardWriteAndReloadManifestIfNeeded(method, args) {
+  if (!(await forwardAsyncStorageWriteIfNeeded(method, args))) {
+    return false;
+  }
+  await NativeModule.reloadManifest();
+  return true;
+}
+async function runLocalWriteWithFreshManifest(write) {
+  // This narrows the local-write stale manifest window, but it does not make
+  // uninjected writes cross-runtime serialized. Writes that already completed
+  // before forwarder installation keep the legacy local-write semantics.
+  await NativeModule.reloadManifest();
+  await write();
+}
+async function runReadWithFreshManifest(read) {
+  // iOS keeps one manifest cache per runtime/module instance while the files on
+  // disk are shared. Refresh before reads so main can observe bg-origin writes
+  // without routing reads through the bg runtime. Android/web implementations
+  // expose reloadManifest as a no-op.
+  await NativeModule.reloadManifest();
+  return read();
+}
+async function forwardClearAsMultiRemoveIfNeeded() {
+  if (!shouldForwardAsyncStorageWrite()) {
+    return false;
+  }
+  await NativeModule.reloadManifest();
+  const keys = [...(await NativeModule.getAllKeys())];
+  // Use the fresh main-runtime key list; bg clear may enumerate from a stale
+  // manifest.
+  await forwardAsyncStorageWrite('multiRemove', [keys]);
+  await NativeModule.reloadManifest();
+  return true;
+}
 function createAsyncStorage() {
   const getItem = async (key, callback) => {
     try {
-      const result = await NativeModule.multiGet([key]);
+      const result = await runReadWithFreshManifest(() => NativeModule.multiGet([key]));
       const value = result?.[0]?.[1] ?? null;
       callback?.(null, value);
       return value;
@@ -17,8 +51,8 @@ function createAsyncStorage() {
   };
   const setItem = async (key, value, callback) => {
     try {
-      if (!(await forwardAsyncStorageWriteIfNeeded('multiSet', [[[key, value]]]))) {
-        await NativeModule.multiSet([[key, value]]);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiSet', [[[key, value]]]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiSet([[key, value]]));
       }
       callback?.(null);
     } catch (e) {
@@ -29,8 +63,8 @@ function createAsyncStorage() {
   };
   const removeItem = async (key, callback) => {
     try {
-      if (!(await forwardAsyncStorageWriteIfNeeded('multiRemove', [[key]]))) {
-        await NativeModule.multiRemove([key]);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [[key]]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiRemove([key]));
       }
       callback?.(null);
     } catch (e) {
@@ -41,8 +75,8 @@ function createAsyncStorage() {
   };
   const mergeItem = async (key, value, callback) => {
     try {
-      if (!(await forwardAsyncStorageWriteIfNeeded('multiMerge', [[[key, value]]]))) {
-        await NativeModule.multiMerge([[key, value]]);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [[[key, value]]]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiMerge([[key, value]]));
       }
       callback?.(null);
     } catch (e) {
@@ -53,7 +87,7 @@ function createAsyncStorage() {
   };
   const clear = async callback => {
     try {
-      if (!(await forwardAsyncStorageWriteIfNeeded('clear', []))) {
+      if (!(await forwardClearAsMultiRemoveIfNeeded())) {
         await NativeModule.clear();
       }
       callback?.(null);
@@ -65,7 +99,7 @@ function createAsyncStorage() {
   };
   const getAllKeys = async callback => {
     try {
-      const keys = await NativeModule.getAllKeys();
+      const keys = await runReadWithFreshManifest(() => NativeModule.getAllKeys());
       callback?.(null, keys);
       return keys;
     } catch (e) {
@@ -79,7 +113,7 @@ function createAsyncStorage() {
   };
   const multiGet = async (keys, callback) => {
     try {
-      const result = await NativeModule.multiGet([...keys]);
+      const result = await runReadWithFreshManifest(() => NativeModule.multiGet([...keys]));
       callback?.(null, result);
       return result;
     } catch (e) {
@@ -91,8 +125,8 @@ function createAsyncStorage() {
   const multiSet = async (keyValuePairs, callback) => {
     try {
       const mutablePairs = keyValuePairs.map(([k, v]) => [k, v]);
-      if (!(await forwardAsyncStorageWriteIfNeeded('multiSet', [mutablePairs]))) {
-        await NativeModule.multiSet(mutablePairs);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiSet', [mutablePairs]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiSet(mutablePairs));
       }
       callback?.(null);
     } catch (e) {
@@ -104,8 +138,8 @@ function createAsyncStorage() {
   const multiRemove = async (keys, callback) => {
     try {
       const mutableKeys = [...keys];
-      if (!(await forwardAsyncStorageWriteIfNeeded('multiRemove', [mutableKeys]))) {
-        await NativeModule.multiRemove(mutableKeys);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [mutableKeys]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiRemove(mutableKeys));
       }
       callback?.(null);
     } catch (e) {
@@ -116,8 +150,8 @@ function createAsyncStorage() {
   };
   const multiMerge = async (keyValuePairs, callback) => {
     try {
-      if (!(await forwardAsyncStorageWriteIfNeeded('multiMerge', [keyValuePairs]))) {
-        await NativeModule.multiMerge(keyValuePairs);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [keyValuePairs]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiMerge(keyValuePairs));
       }
       callback?.(null);
     } catch (e) {

package/lib/module/runtimeConfig.js

@@ -20,15 +20,21 @@ function getWriteForwarder() {
 function shouldForwardWriteToBackground() {
   return getShouldForwardWriteGetter()?.() ?? false;
 }
-export async function forwardAsyncStorageWriteIfNeeded(method, args) {
-  if (!shouldForwardWriteToBackground()) {
-    return false;
-  }
+export function shouldForwardAsyncStorageWrite() {
+  return shouldForwardWriteToBackground();
+}
+export async function forwardAsyncStorageWrite(method, args) {
   const forwarder = getWriteForwarder();
   if (!forwarder) {
     throw new Error('AsyncStorage write forwarder is not configured.');
   }
   await forwarder(method, args);
+}
+export async function forwardAsyncStorageWriteIfNeeded(method, args) {
+  if (!shouldForwardAsyncStorageWrite()) {
+    return false;
+  }
+  await forwardAsyncStorageWrite(method, args);
   return true;
 }
 //# sourceMappingURL=runtimeConfig.js.map

package/lib/typescript/src/NativeAsyncStorage.d.ts

@@ -6,6 +6,7 @@ export interface Spec extends TurboModule {
     multiMerge(keyValuePairs: [string, string][]): Promise<void>;
     getAllKeys(): Promise<string[]>;
     clear(): Promise<void>;
+    reloadManifest(): Promise<void>;
 }
 declare const _default: Spec;
 export default _default;

package/lib/typescript/src/NativeAsyncStorage.web.d.ts

@@ -6,6 +6,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 import type { AsyncStorageStatic } from './types';
-declare const AsyncStorage: AsyncStorageStatic;
+type AsyncStorageWebStatic = AsyncStorageStatic & {
+    reloadManifest: () => Promise<void>;
+};
+declare const AsyncStorage: AsyncStorageWebStatic;
 export default AsyncStorage;
 //# sourceMappingURL=NativeAsyncStorage.web.d.ts.map

package/lib/typescript/src/runtimeConfig.d.ts

@@ -10,5 +10,7 @@ export type AsyncStorageShouldForwardWriteGetter = () => boolean;
 export type AsyncStorageWriteForwarder = <T extends AsyncStorageWriteMethod>(method: T, args: AsyncStorageWriteArgs<T>) => Promise<void>;
 export declare function setAsyncStorageShouldForwardWriteGetter(getter: AsyncStorageShouldForwardWriteGetter): void;
 export declare function setAsyncStorageWriteForwarder(forwarder: AsyncStorageWriteForwarder): void;
+export declare function shouldForwardAsyncStorageWrite(): boolean;
+export declare function forwardAsyncStorageWrite<T extends AsyncStorageWriteMethod>(method: T, args: AsyncStorageWriteArgs<T>): Promise<void>;
 export declare function forwardAsyncStorageWriteIfNeeded<T extends AsyncStorageWriteMethod>(method: T, args: AsyncStorageWriteArgs<T>): Promise<boolean>;
 //# sourceMappingURL=runtimeConfig.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-async-storage",
-  "version": "3.0.76",
+  "version": "3.0.78",
   "description": "react-native-async-storage",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/NativeAsyncStorage.ts

@@ -8,6 +8,7 @@ export interface Spec extends TurboModule {
   multiMerge(keyValuePairs: [string, string][]): Promise<void>;
   getAllKeys(): Promise<string[]>;
   clear(): Promise<void>;
+  reloadManifest(): Promise<void>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('RNCAsyncStorage');

package/src/NativeAsyncStorage.web.ts

@@ -17,6 +17,9 @@ import type {
 type OnMultiResult = Function;
 // eslint-disable-next-line @typescript-eslint/ban-types
 type OnResult = Function;
+type AsyncStorageWebStatic = AsyncStorageStatic & {
+  reloadManifest: () => Promise<void>;
+};
 
 const merge = mergeOptions.bind({
   concatArrays: true,
@@ -73,7 +76,7 @@ function createPromiseAll<
   );
 }
 
-const AsyncStorage: AsyncStorageStatic = {
+const AsyncStorage: AsyncStorageWebStatic = {
   /**
    * Fetches `key` value.
    */
@@ -176,6 +179,8 @@ const AsyncStorage: AsyncStorageStatic = {
     );
     return createPromiseAll(promises, callback);
   },
+
+  reloadManifest: () => Promise.resolve(),
 };
 
 export default AsyncStorage;

package/src/index.tsx

@@ -1,11 +1,63 @@
 import NativeModule from './NativeAsyncStorage';
-import { forwardAsyncStorageWriteIfNeeded } from './runtimeConfig';
+import {
+  forwardAsyncStorageWrite,
+  forwardAsyncStorageWriteIfNeeded,
+  shouldForwardAsyncStorageWrite,
+} from './runtimeConfig';
+import type {
+  AsyncStorageWriteArgs,
+  AsyncStorageWriteMethod,
+} from './runtimeConfig';
 import type { AsyncStorageStatic } from './types';
 
+async function forwardWriteAndReloadManifestIfNeeded<
+  T extends AsyncStorageWriteMethod
+>(method: T, args: AsyncStorageWriteArgs<T>) {
+  if (!(await forwardAsyncStorageWriteIfNeeded(method, args))) {
+    return false;
+  }
+
+  await NativeModule.reloadManifest();
+  return true;
+}
+
+async function runLocalWriteWithFreshManifest(write: () => Promise<void>) {
+  // This narrows the local-write stale manifest window, but it does not make
+  // uninjected writes cross-runtime serialized. Writes that already completed
+  // before forwarder installation keep the legacy local-write semantics.
+  await NativeModule.reloadManifest();
+  await write();
+}
+
+async function runReadWithFreshManifest<T>(read: () => Promise<T>): Promise<T> {
+  // iOS keeps one manifest cache per runtime/module instance while the files on
+  // disk are shared. Refresh before reads so main can observe bg-origin writes
+  // without routing reads through the bg runtime. Android/web implementations
+  // expose reloadManifest as a no-op.
+  await NativeModule.reloadManifest();
+  return read();
+}
+
+async function forwardClearAsMultiRemoveIfNeeded() {
+  if (!shouldForwardAsyncStorageWrite()) {
+    return false;
+  }
+
+  await NativeModule.reloadManifest();
+  const keys = [...(await NativeModule.getAllKeys())];
+  // Use the fresh main-runtime key list; bg clear may enumerate from a stale
+  // manifest.
+  await forwardAsyncStorageWrite('multiRemove', [keys]);
+  await NativeModule.reloadManifest();
+  return true;
+}
+
 function createAsyncStorage(): AsyncStorageStatic {
   const getItem: AsyncStorageStatic['getItem'] = async (key, callback) => {
     try {
-      const result = await NativeModule.multiGet([key]);
+      const result = await runReadWithFreshManifest(() =>
+        NativeModule.multiGet([key])
+      );
       const value = result?.[0]?.[1] ?? null;
       callback?.(null, value);
       return value;
@@ -23,9 +75,13 @@ function createAsyncStorage(): AsyncStorageStatic {
   ) => {
     try {
       if (
-        !(await forwardAsyncStorageWriteIfNeeded('multiSet', [[[key, value]]]))
+        !(await forwardWriteAndReloadManifestIfNeeded('multiSet', [
+          [[key, value]],
+        ]))
       ) {
-        await NativeModule.multiSet([[key, value]]);
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiSet([[key, value]])
+        );
       }
       callback?.(null);
     } catch (e) {
@@ -40,8 +96,12 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      if (!(await forwardAsyncStorageWriteIfNeeded('multiRemove', [[key]]))) {
-        await NativeModule.multiRemove([key]);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [[key]]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiRemove([key])
+        );
       }
       callback?.(null);
     } catch (e) {
@@ -58,11 +118,13 @@ function createAsyncStorage(): AsyncStorageStatic {
   ) => {
     try {
       if (
-        !(await forwardAsyncStorageWriteIfNeeded('multiMerge', [
+        !(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [
           [[key, value]],
         ]))
       ) {
-        await NativeModule.multiMerge([[key, value]]);
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiMerge([[key, value]])
+        );
       }
       callback?.(null);
     } catch (e) {
@@ -74,7 +136,7 @@ function createAsyncStorage(): AsyncStorageStatic {
 
   const clear: AsyncStorageStatic['clear'] = async (callback) => {
     try {
-      if (!(await forwardAsyncStorageWriteIfNeeded('clear', []))) {
+      if (!(await forwardClearAsMultiRemoveIfNeeded())) {
         await NativeModule.clear();
       }
       callback?.(null);
@@ -87,7 +149,9 @@ function createAsyncStorage(): AsyncStorageStatic {
 
   const getAllKeys: AsyncStorageStatic['getAllKeys'] = async (callback) => {
     try {
-      const keys = await NativeModule.getAllKeys();
+      const keys = await runReadWithFreshManifest(() =>
+        NativeModule.getAllKeys()
+      );
       callback?.(null, keys);
       return keys;
     } catch (e) {
@@ -103,7 +167,9 @@ function createAsyncStorage(): AsyncStorageStatic {
 
   const multiGet: AsyncStorageStatic['multiGet'] = async (keys, callback) => {
     try {
-      const result = await NativeModule.multiGet([...keys]);
+      const result = await runReadWithFreshManifest(() =>
+        NativeModule.multiGet([...keys])
+      );
       callback?.(null, result);
       return result;
     } catch (e) {
@@ -122,9 +188,13 @@ function createAsyncStorage(): AsyncStorageStatic {
         ([k, v]) => [k, v] as [string, string]
       );
       if (
-        !(await forwardAsyncStorageWriteIfNeeded('multiSet', [mutablePairs]))
+        !(await forwardWriteAndReloadManifestIfNeeded('multiSet', [
+          mutablePairs,
+        ]))
       ) {
-        await NativeModule.multiSet(mutablePairs);
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiSet(mutablePairs)
+        );
       }
       callback?.(null);
     } catch (e) {
@@ -141,9 +211,13 @@ function createAsyncStorage(): AsyncStorageStatic {
     try {
       const mutableKeys = [...keys];
       if (
-        !(await forwardAsyncStorageWriteIfNeeded('multiRemove', [mutableKeys]))
+        !(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [
+          mutableKeys,
+        ]))
       ) {
-        await NativeModule.multiRemove(mutableKeys);
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiRemove(mutableKeys)
+        );
       }
       callback?.(null);
     } catch (e) {
@@ -159,9 +233,13 @@ function createAsyncStorage(): AsyncStorageStatic {
   ) => {
     try {
       if (
-        !(await forwardAsyncStorageWriteIfNeeded('multiMerge', [keyValuePairs]))
+        !(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [
+          keyValuePairs,
+        ]))
       ) {
-        await NativeModule.multiMerge(keyValuePairs);
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiMerge(keyValuePairs)
+        );
       }
       callback?.(null);
     } catch (e) {

package/src/runtimeConfig.ts

@@ -59,18 +59,28 @@ function shouldForwardWriteToBackground() {
   return getShouldForwardWriteGetter()?.() ?? false;
 }
 
-export async function forwardAsyncStorageWriteIfNeeded<
-  T extends AsyncStorageWriteMethod
->(method: T, args: AsyncStorageWriteArgs<T>): Promise<boolean> {
-  if (!shouldForwardWriteToBackground()) {
-    return false;
-  }
+export function shouldForwardAsyncStorageWrite() {
+  return shouldForwardWriteToBackground();
+}
 
+export async function forwardAsyncStorageWrite<
+  T extends AsyncStorageWriteMethod
+>(method: T, args: AsyncStorageWriteArgs<T>): Promise<void> {
   const forwarder = getWriteForwarder();
   if (!forwarder) {
     throw new Error('AsyncStorage write forwarder is not configured.');
   }
 
   await forwarder(method, args);
+}
+
+export async function forwardAsyncStorageWriteIfNeeded<
+  T extends AsyncStorageWriteMethod
+>(method: T, args: AsyncStorageWriteArgs<T>): Promise<boolean> {
+  if (!shouldForwardAsyncStorageWrite()) {
+    return false;
+  }
+
+  await forwardAsyncStorageWrite(method, args);
   return true;
 }