@onekeyfe/react-native-async-storage 3.0.75 → 3.0.77

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/index.js

@@ -1,6 +1,18 @@
 "use strict";
 
 import NativeModule from './NativeAsyncStorage';
+import { forwardAsyncStorageWriteIfNeeded } from "./runtimeConfig.js";
+async function forwardWriteAndReloadManifestIfNeeded(method, args) {
+  if (!(await forwardAsyncStorageWriteIfNeeded(method, args))) {
+    return false;
+  }
+  await NativeModule.reloadManifest();
+  return true;
+}
+async function runLocalWriteWithFreshManifest(write) {
+  await NativeModule.reloadManifest();
+  await write();
+}
 function createAsyncStorage() {
   const getItem = async (key, callback) => {
     try {
@@ -16,7 +28,9 @@ function createAsyncStorage() {
   };
   const setItem = async (key, value, callback) => {
     try {
-      await NativeModule.multiSet([[key, value]]);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiSet', [[[key, value]]]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiSet([[key, value]]));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -26,7 +40,9 @@ function createAsyncStorage() {
   };
   const removeItem = async (key, callback) => {
     try {
-      await NativeModule.multiRemove([key]);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [[key]]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiRemove([key]));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -36,7 +52,9 @@ function createAsyncStorage() {
   };
   const mergeItem = async (key, value, callback) => {
     try {
-      await NativeModule.multiMerge([[key, value]]);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [[[key, value]]]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiMerge([[key, value]]));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -46,7 +64,9 @@ function createAsyncStorage() {
   };
   const clear = async callback => {
     try {
-      await NativeModule.clear();
+      if (!(await forwardWriteAndReloadManifestIfNeeded('clear', []))) {
+        await NativeModule.clear();
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -82,7 +102,9 @@ function createAsyncStorage() {
   const multiSet = async (keyValuePairs, callback) => {
     try {
       const mutablePairs = keyValuePairs.map(([k, v]) => [k, v]);
-      await NativeModule.multiSet(mutablePairs);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiSet', [mutablePairs]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiSet(mutablePairs));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -92,7 +114,10 @@ function createAsyncStorage() {
   };
   const multiRemove = async (keys, callback) => {
     try {
-      await NativeModule.multiRemove([...keys]);
+      const mutableKeys = [...keys];
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [mutableKeys]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiRemove(mutableKeys));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -102,7 +127,9 @@ function createAsyncStorage() {
   };
   const multiMerge = async (keyValuePairs, callback) => {
     try {
-      await NativeModule.multiMerge(keyValuePairs);
+      if (!(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [keyValuePairs]))) {
+        await runLocalWriteWithFreshManifest(() => NativeModule.multiMerge(keyValuePairs));
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -126,4 +153,5 @@ function createAsyncStorage() {
 }
 const AsyncStorage = createAsyncStorage();
 export default AsyncStorage;
+export { setAsyncStorageShouldForwardWriteGetter, setAsyncStorageWriteForwarder } from "./runtimeConfig.js";
 //# sourceMappingURL=index.js.map

package/lib/module/runtimeConfig.js

@@ -0,0 +1,34 @@
+"use strict";
+
+const runtimeGlobal = globalThis;
+let shouldForwardWriteGetter = runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter;
+let writeForwarder = runtimeGlobal.__onekeyAsyncStorageWriteForwarder;
+export function setAsyncStorageShouldForwardWriteGetter(getter) {
+  shouldForwardWriteGetter = getter;
+  runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter = getter;
+}
+export function setAsyncStorageWriteForwarder(forwarder) {
+  writeForwarder = forwarder;
+  runtimeGlobal.__onekeyAsyncStorageWriteForwarder = forwarder;
+}
+function getShouldForwardWriteGetter() {
+  return shouldForwardWriteGetter ?? runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter;
+}
+function getWriteForwarder() {
+  return writeForwarder ?? runtimeGlobal.__onekeyAsyncStorageWriteForwarder;
+}
+function shouldForwardWriteToBackground() {
+  return getShouldForwardWriteGetter()?.() ?? false;
+}
+export async function forwardAsyncStorageWriteIfNeeded(method, args) {
+  if (!shouldForwardWriteToBackground()) {
+    return false;
+  }
+  const forwarder = getWriteForwarder();
+  if (!forwarder) {
+    throw new Error('AsyncStorage write forwarder is not configured.');
+  }
+  await forwarder(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/index.d.ts

@@ -1,5 +1,7 @@
 import type { AsyncStorageStatic } from './types';
 declare const AsyncStorage: AsyncStorageStatic;
 export default AsyncStorage;
+export type { AsyncStorageShouldForwardWriteGetter, AsyncStorageWriteArgs, AsyncStorageWriteArgsByMethod, AsyncStorageWriteForwarder, AsyncStorageWriteMethod, } from './runtimeConfig';
 export type { AsyncStorageStatic, Callback, CallbackWithResult, KeyValuePair, MultiCallback, MultiGetCallback, } from './types';
+export { setAsyncStorageShouldForwardWriteGetter, setAsyncStorageWriteForwarder, } from './runtimeConfig';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,14 @@
+export type AsyncStorageWriteArgsByMethod = {
+    clear: [];
+    multiSet: [[string, string][]];
+    multiRemove: [string[]];
+    multiMerge: [[string, string][]];
+};
+export type AsyncStorageWriteMethod = keyof AsyncStorageWriteArgsByMethod;
+export type AsyncStorageWriteArgs<T extends AsyncStorageWriteMethod = AsyncStorageWriteMethod> = AsyncStorageWriteArgsByMethod[T];
+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 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.75",
+  "version": "3.0.77",
   "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/index.tsx

@@ -1,6 +1,27 @@
 import NativeModule from './NativeAsyncStorage';
+import { forwardAsyncStorageWriteIfNeeded } 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>) {
+  await NativeModule.reloadManifest();
+  await write();
+}
+
 function createAsyncStorage(): AsyncStorageStatic {
   const getItem: AsyncStorageStatic['getItem'] = async (key, callback) => {
     try {
@@ -21,7 +42,15 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiSet([[key, value]]);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiSet', [
+          [[key, value]],
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiSet([[key, value]])
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -35,7 +64,13 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiRemove([key]);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [[key]]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiRemove([key])
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -50,7 +85,15 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiMerge([[key, value]]);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [
+          [[key, value]],
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiMerge([[key, value]])
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -61,7 +104,9 @@ function createAsyncStorage(): AsyncStorageStatic {
 
   const clear: AsyncStorageStatic['clear'] = async (callback) => {
     try {
-      await NativeModule.clear();
+      if (!(await forwardWriteAndReloadManifestIfNeeded('clear', []))) {
+        await NativeModule.clear();
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -106,7 +151,15 @@ function createAsyncStorage(): AsyncStorageStatic {
       const mutablePairs = keyValuePairs.map(
         ([k, v]) => [k, v] as [string, string]
       );
-      await NativeModule.multiSet(mutablePairs);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiSet', [
+          mutablePairs,
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiSet(mutablePairs)
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -120,7 +173,16 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiRemove([...keys]);
+      const mutableKeys = [...keys];
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiRemove', [
+          mutableKeys,
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiRemove(mutableKeys)
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -134,7 +196,15 @@ function createAsyncStorage(): AsyncStorageStatic {
     callback
   ) => {
     try {
-      await NativeModule.multiMerge(keyValuePairs);
+      if (
+        !(await forwardWriteAndReloadManifestIfNeeded('multiMerge', [
+          keyValuePairs,
+        ]))
+      ) {
+        await runLocalWriteWithFreshManifest(() =>
+          NativeModule.multiMerge(keyValuePairs)
+        );
+      }
       callback?.(null);
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
@@ -162,6 +232,13 @@ const AsyncStorage = createAsyncStorage();
 
 export default AsyncStorage;
 
+export type {
+  AsyncStorageShouldForwardWriteGetter,
+  AsyncStorageWriteArgs,
+  AsyncStorageWriteArgsByMethod,
+  AsyncStorageWriteForwarder,
+  AsyncStorageWriteMethod,
+} from './runtimeConfig';
 export type {
   AsyncStorageStatic,
   Callback,
@@ -170,3 +247,7 @@ export type {
   MultiCallback,
   MultiGetCallback,
 } from './types';
+export {
+  setAsyncStorageShouldForwardWriteGetter,
+  setAsyncStorageWriteForwarder,
+} from './runtimeConfig';

package/src/runtimeConfig.ts

@@ -0,0 +1,76 @@
+export type AsyncStorageWriteArgsByMethod = {
+  clear: [];
+  multiSet: [[string, string][]];
+  multiRemove: [string[]];
+  multiMerge: [[string, string][]];
+};
+
+export type AsyncStorageWriteMethod = keyof AsyncStorageWriteArgsByMethod;
+
+export type AsyncStorageWriteArgs<
+  T extends AsyncStorageWriteMethod = AsyncStorageWriteMethod
+> = AsyncStorageWriteArgsByMethod[T];
+
+export type AsyncStorageShouldForwardWriteGetter = () => boolean;
+
+export type AsyncStorageWriteForwarder = <T extends AsyncStorageWriteMethod>(
+  method: T,
+  args: AsyncStorageWriteArgs<T>
+) => Promise<void>;
+
+type AsyncStorageRuntimeGlobal = typeof globalThis & {
+  __onekeyAsyncStorageShouldForwardWriteGetter?: AsyncStorageShouldForwardWriteGetter;
+  __onekeyAsyncStorageWriteForwarder?: AsyncStorageWriteForwarder;
+};
+
+const runtimeGlobal = globalThis as AsyncStorageRuntimeGlobal;
+
+let shouldForwardWriteGetter: AsyncStorageShouldForwardWriteGetter | undefined =
+  runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter;
+let writeForwarder: AsyncStorageWriteForwarder | undefined =
+  runtimeGlobal.__onekeyAsyncStorageWriteForwarder;
+
+export function setAsyncStorageShouldForwardWriteGetter(
+  getter: AsyncStorageShouldForwardWriteGetter
+) {
+  shouldForwardWriteGetter = getter;
+  runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter = getter;
+}
+
+export function setAsyncStorageWriteForwarder(
+  forwarder: AsyncStorageWriteForwarder
+) {
+  writeForwarder = forwarder;
+  runtimeGlobal.__onekeyAsyncStorageWriteForwarder = forwarder;
+}
+
+function getShouldForwardWriteGetter() {
+  return (
+    shouldForwardWriteGetter ??
+    runtimeGlobal.__onekeyAsyncStorageShouldForwardWriteGetter
+  );
+}
+
+function getWriteForwarder() {
+  return writeForwarder ?? runtimeGlobal.__onekeyAsyncStorageWriteForwarder;
+}
+
+function shouldForwardWriteToBackground() {
+  return getShouldForwardWriteGetter()?.() ?? false;
+}
+
+export async function forwardAsyncStorageWriteIfNeeded<
+  T extends AsyncStorageWriteMethod
+>(method: T, args: AsyncStorageWriteArgs<T>): Promise<boolean> {
+  if (!shouldForwardWriteToBackground()) {
+    return false;
+  }
+
+  const forwarder = getWriteForwarder();
+  if (!forwarder) {
+    throw new Error('AsyncStorage write forwarder is not configured.');
+  }
+
+  await forwarder(method, args);
+  return true;
+}