@onekeyfe/react-native-async-storage 1.1.55

package/AsyncStorage.podspec

@@ -0,0 +1,19 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "AsyncStorage"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/react-native-async-storage.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  install_modules_dependencies(s)
+end

package/ios/AsyncStorage.h

@@ -0,0 +1,27 @@
+#import <AsyncStorageSpec/AsyncStorageSpec.h>
+
+@interface AsyncStorage : NativeRNCAsyncStorageSpecBase <NativeRNCAsyncStorageSpec>
+
+- (void)multiGet:(NSArray<NSString *> *)keys
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject;
+
+- (void)multiSet:(NSArray<NSArray<NSString *> *> *)keyValuePairs
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject;
+
+- (void)multiRemove:(NSArray<NSString *> *)keys
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject;
+
+- (void)multiMerge:(NSArray<NSArray<NSString *> *> *)keyValuePairs
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject;
+
+- (void)getAllKeys:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject;
+
+- (void)clear:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject;
+
+@end

package/ios/AsyncStorage.mm

@@ -0,0 +1,714 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Adapted to a proper TurboModule (no RCT_EXPORT_MODULE / RCT_EXPORT_METHOD)
+ * so it works in both the main and background Hermes runtimes.
+ */
+
+#import "AsyncStorage.h"
+
+#import <React/RCTConvert.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+static NSString *const RCTStorageDirectory = @"RCTAsyncLocalStorage_V1";
+static NSString *const RCTOldStorageDirectory = @"RNCAsyncLocalStorage_V1";
+static NSString *const RCTExpoStorageDirectory = @"RCTAsyncLocalStorage";
+static NSString *const RCTManifestFileName = @"manifest.json";
+static const NSUInteger RCTInlineValueThreshold = 1024;
+
+#pragma mark - Static helper functions
+
+static NSDictionary *RCTErrorForKey(NSString *key)
+{
+    if (![key isKindOfClass:[NSString class]]) {
+        return RCTMakeAndLogError(@"Invalid key - must be a string.  Key: ", key, @{@"key": key});
+    } else if (key.length < 1) {
+        return RCTMakeAndLogError(
+            @"Invalid key - must be at least one character.  Key: ", key, @{@"key": key});
+    } else {
+        return nil;
+    }
+}
+
+static BOOL RCTAsyncStorageSetExcludedFromBackup(NSString *path, NSNumber *isExcluded)
+{
+    NSFileManager *fileManager = [[NSFileManager alloc] init];
+
+    BOOL isDir;
+    BOOL exists = [fileManager fileExistsAtPath:path isDirectory:&isDir];
+    BOOL success = false;
+
+    if (isDir && exists) {
+        NSURL *pathUrl = [NSURL fileURLWithPath:path];
+        NSError *error = nil;
+        success = [pathUrl setResourceValue:isExcluded
+                                     forKey:NSURLIsExcludedFromBackupKey
+                                      error:&error];
+
+        if (!success) {
+            NSLog(@"Could not exclude AsyncStorage dir from backup %@", error);
+        }
+    }
+    return success;
+}
+
+static void RCTAppendError(NSDictionary *error, NSMutableArray<NSDictionary *> **errors)
+{
+    if (error && errors) {
+        if (!*errors) {
+            *errors = [NSMutableArray new];
+        }
+        [*errors addObject:error];
+    }
+}
+
+static NSString *RCTReadFile(NSString *filePath, NSString *key, NSDictionary **errorOut)
+{
+    if ([[NSFileManager defaultManager] fileExistsAtPath:filePath]) {
+        NSError *error;
+        NSStringEncoding encoding;
+        NSString *entryString = [NSString stringWithContentsOfFile:filePath
+                                                      usedEncoding:&encoding
+                                                             error:&error];
+        NSDictionary *extraData = @{@"key": RCTNullIfNil(key)};
+
+        if (error) {
+            if (errorOut) {
+                *errorOut = RCTMakeError(@"Failed to read storage file.", error, extraData);
+            }
+            return nil;
+        }
+
+        if (encoding != NSUTF8StringEncoding) {
+            if (errorOut) {
+                *errorOut =
+                    RCTMakeError(@"Incorrect encoding of storage file: ", @(encoding), extraData);
+            }
+            return nil;
+        }
+        return entryString;
+    }
+
+    return nil;
+}
+
+static NSString *RCTCreateStorageDirectoryPath_deprecated(NSString *storageDir)
+{
+    NSString *storageDirectoryPath;
+#if TARGET_OS_TV
+    storageDirectoryPath =
+        NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).firstObject;
+#else
+    storageDirectoryPath =
+        NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).firstObject;
+#endif
+    storageDirectoryPath = [storageDirectoryPath stringByAppendingPathComponent:storageDir];
+    return storageDirectoryPath;
+}
+
+static NSString *RCTCreateStorageDirectoryPath(NSString *storageDir)
+{
+    NSString *storageDirectoryPath = @"";
+
+#if TARGET_OS_TV
+    storageDirectoryPath =
+        NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).firstObject;
+#else
+    storageDirectoryPath =
+        NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES)
+            .firstObject;
+    storageDirectoryPath = [storageDirectoryPath
+        stringByAppendingPathComponent:[[NSBundle mainBundle] bundleIdentifier]];
+#endif
+
+    storageDirectoryPath = [storageDirectoryPath stringByAppendingPathComponent:storageDir];
+
+    return storageDirectoryPath;
+}
+
+static NSString *RCTGetStorageDirectory()
+{
+    static NSString *storageDirectory = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+#if TARGET_OS_TV
+      RCTLogWarn(
+          @"Persistent storage is not supported on tvOS, your data may be removed at any point.");
+#endif
+      storageDirectory = RCTCreateStorageDirectoryPath(RCTStorageDirectory);
+    });
+    return storageDirectory;
+}
+
+static NSString *RCTCreateManifestFilePath(NSString *storageDirectory)
+{
+    return [storageDirectory stringByAppendingPathComponent:RCTManifestFileName];
+}
+
+static NSString *RCTGetManifestFilePath()
+{
+    static NSString *manifestFilePath = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      manifestFilePath = RCTCreateManifestFilePath(RCTStorageDirectory);
+    });
+    return manifestFilePath;
+}
+
+// Only merges objects - all other types are just clobbered (including arrays)
+static BOOL RCTMergeRecursive(NSMutableDictionary *destination, NSDictionary *source)
+{
+    BOOL modified = NO;
+    for (NSString *key in source) {
+        id sourceValue = source[key];
+        id destinationValue = destination[key];
+        if ([sourceValue isKindOfClass:[NSDictionary class]]) {
+            if ([destinationValue isKindOfClass:[NSDictionary class]]) {
+                if ([destinationValue classForCoder] != [NSMutableDictionary class]) {
+                    destinationValue = [destinationValue mutableCopy];
+                }
+                if (RCTMergeRecursive(destinationValue, sourceValue)) {
+                    destination[key] = destinationValue;
+                    modified = YES;
+                }
+            } else {
+                destination[key] = [sourceValue copy];
+                modified = YES;
+            }
+        } else if (![source isEqual:destinationValue]) {
+            destination[key] = [sourceValue copy];
+            modified = YES;
+        }
+    }
+    return modified;
+}
+
+static dispatch_queue_t RCTGetMethodQueue()
+{
+    // We want all instances to share the same queue since they will be reading/writing the same
+    // files.
+    static dispatch_queue_t queue;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      queue =
+          dispatch_queue_create("com.facebook.react.AsyncLocalStorageQueue", DISPATCH_QUEUE_SERIAL);
+    });
+    return queue;
+}
+
+static NSCache *RCTGetCache()
+{
+    // We want all instances to share the same cache since they will be reading/writing the same
+    // files.
+    static NSCache *cache;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      cache = [NSCache new];
+      cache.totalCostLimit = 2 * 1024 * 1024;  // 2MB
+
+#if !TARGET_OS_OSX
+      // Clear cache in the event of a memory warning
+      [[NSNotificationCenter defaultCenter]
+          addObserverForName:UIApplicationDidReceiveMemoryWarningNotification
+                      object:nil
+                       queue:nil
+                  usingBlock:^(__unused NSNotification *note) {
+                    [cache removeAllObjects];
+                  }];
+#endif  // !TARGET_OS_OSX
+    });
+    return cache;
+}
+
+static BOOL RCTHasCreatedStorageDirectory = NO;
+
+static NSDictionary *RCTDeleteStorageDirectory()
+{
+    NSError *error;
+    [[NSFileManager defaultManager] removeItemAtPath:RCTGetStorageDirectory() error:&error];
+    RCTHasCreatedStorageDirectory = NO;
+    if (error && error.code != NSFileNoSuchFileError) {
+        return RCTMakeError(@"Failed to delete storage directory.", error, nil);
+    }
+    return nil;
+}
+
+static NSDate *RCTManifestModificationDate(NSString *manifestFilePath)
+{
+    NSDictionary *attributes =
+        [[NSFileManager defaultManager] attributesOfItemAtPath:manifestFilePath error:nil];
+    return [attributes fileModificationDate];
+}
+
+static void RCTStorageDirectoryMigrationLogError(NSString *reason, NSError *error)
+{
+    RCTLogWarn(@"%@: %@", reason, error ? error.description : @"");
+}
+
+static void RCTStorageDirectoryCleanupOld(NSString *oldDirectoryPath)
+{
+    NSError *error;
+    if (![[NSFileManager defaultManager] removeItemAtPath:oldDirectoryPath error:&error]) {
+        RCTStorageDirectoryMigrationLogError(
+            @"Failed to remove old storage directory during migration", error);
+    }
+}
+
+static void _createStorageDirectory(NSString *storageDirectory, NSError **error)
+{
+    [[NSFileManager defaultManager] createDirectoryAtPath:storageDirectory
+                              withIntermediateDirectories:YES
+                                               attributes:nil
+                                                    error:error];
+}
+
+static void RCTStorageDirectoryMigrate(NSString *oldDirectoryPath,
+                                       NSString *newDirectoryPath,
+                                       BOOL shouldCleanupOldDirectory)
+{
+    NSError *error;
+    if (![[NSFileManager defaultManager] copyItemAtPath:oldDirectoryPath
+                                                 toPath:newDirectoryPath
+                                                  error:&error]) {
+        if (error != nil && error.code == 4 &&
+            [newDirectoryPath isEqualToString:RCTGetStorageDirectory()]) {
+            error = nil;
+            _createStorageDirectory(RCTCreateStorageDirectoryPath(@""), &error);
+            if (error == nil) {
+                RCTStorageDirectoryMigrate(
+                    oldDirectoryPath, newDirectoryPath, shouldCleanupOldDirectory);
+            } else {
+                RCTStorageDirectoryMigrationLogError(
+                    @"Failed to create storage directory during migration.", error);
+            }
+        } else {
+            RCTStorageDirectoryMigrationLogError(
+                @"Failed to copy old storage directory to new storage directory location during "
+                @"migration",
+                error);
+        }
+    } else if (shouldCleanupOldDirectory) {
+        RCTStorageDirectoryCleanupOld(oldDirectoryPath);
+    }
+}
+
+static NSString *RCTGetStoragePathForMigration()
+{
+    BOOL isDir;
+    NSString *oldStoragePath = RCTCreateStorageDirectoryPath_deprecated(RCTOldStorageDirectory);
+    NSString *expoStoragePath = RCTCreateStorageDirectoryPath_deprecated(RCTExpoStorageDirectory);
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    BOOL oldStorageDirectoryExists =
+        [fileManager fileExistsAtPath:oldStoragePath isDirectory:&isDir] && isDir;
+    BOOL expoStorageDirectoryExists =
+        [fileManager fileExistsAtPath:expoStoragePath isDirectory:&isDir] && isDir;
+
+    if (oldStorageDirectoryExists && expoStorageDirectoryExists) {
+        if ([RCTManifestModificationDate(RCTCreateManifestFilePath(oldStoragePath))
+                compare:RCTManifestModificationDate(RCTCreateManifestFilePath(expoStoragePath))] ==
+            NSOrderedDescending) {
+            RCTStorageDirectoryCleanupOld(expoStoragePath);
+            return oldStoragePath;
+        } else {
+            RCTStorageDirectoryCleanupOld(oldStoragePath);
+            return expoStoragePath;
+        }
+    } else if (oldStorageDirectoryExists) {
+        return oldStoragePath;
+    } else if (expoStorageDirectoryExists) {
+        return expoStoragePath;
+    } else {
+        return nil;
+    }
+}
+
+static void RCTStorageDirectoryMigrationCheck(NSString *fromStorageDirectory,
+                                              NSString *toStorageDirectory,
+                                              BOOL shouldCleanupOldDirectoryAndOverwriteNewDirectory)
+{
+    NSError *error;
+    BOOL isDir;
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    if ([fileManager fileExistsAtPath:fromStorageDirectory isDirectory:&isDir] && isDir) {
+        if ([fileManager fileExistsAtPath:toStorageDirectory]) {
+            if ([RCTManifestModificationDate(RCTCreateManifestFilePath(toStorageDirectory))
+                    compare:RCTManifestModificationDate(
+                                RCTCreateManifestFilePath(fromStorageDirectory))] == 1) {
+                if (shouldCleanupOldDirectoryAndOverwriteNewDirectory) {
+                    RCTStorageDirectoryCleanupOld(fromStorageDirectory);
+                }
+            } else if (shouldCleanupOldDirectoryAndOverwriteNewDirectory) {
+                if (![fileManager removeItemAtPath:toStorageDirectory error:&error]) {
+                    RCTStorageDirectoryMigrationLogError(
+                        @"Failed to remove new storage directory during migration", error);
+                } else {
+                    RCTStorageDirectoryMigrate(fromStorageDirectory,
+                                               toStorageDirectory,
+                                               shouldCleanupOldDirectoryAndOverwriteNewDirectory);
+                }
+            }
+        } else {
+            RCTStorageDirectoryMigrate(fromStorageDirectory,
+                                       toStorageDirectory,
+                                       shouldCleanupOldDirectoryAndOverwriteNewDirectory);
+        }
+    }
+}
+
+#pragma mark - AsyncStorage
+
+@implementation AsyncStorage {
+    BOOL _haveSetup;
+    // The manifest is a dictionary of all keys with small values inlined.  Null values indicate
+    // values that are stored in separate files (as opposed to nil values which don't exist).  The
+    // manifest is read off disk at startup, and written to disk after all mutations.
+    NSMutableDictionary<NSString *, NSString *> *_manifest;
+}
+
++ (NSString *)moduleName
+{
+    return @"RNCAsyncStorage";
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeRNCAsyncStorageSpecJSI>(params);
+}
+
+- (instancetype)init
+{
+    if (!(self = [super init])) {
+        return nil;
+    }
+
+    NSString *oldStoragePath = RCTGetStoragePathForMigration();
+    if (oldStoragePath != nil) {
+        RCTStorageDirectoryMigrationCheck(
+            oldStoragePath, RCTCreateStorageDirectoryPath_deprecated(RCTStorageDirectory), YES);
+    }
+
+    RCTStorageDirectoryMigrationCheck(RCTCreateStorageDirectoryPath_deprecated(RCTStorageDirectory),
+                                      RCTCreateStorageDirectoryPath(RCTStorageDirectory),
+                                      NO);
+
+    return self;
+}
+
+- (NSString *)_filePathForKey:(NSString *)key
+{
+    NSString *safeFileName = RCTMD5Hash(key);
+    return [RCTGetStorageDirectory() stringByAppendingPathComponent:safeFileName];
+}
+
+- (NSDictionary *)_ensureSetup
+{
+    NSError *error = nil;
+    if (!RCTHasCreatedStorageDirectory) {
+        _createStorageDirectory(RCTGetStorageDirectory(), &error);
+        if (error) {
+            return RCTMakeError(@"Failed to create storage directory.", error, nil);
+        }
+        RCTHasCreatedStorageDirectory = YES;
+    }
+
+    if (!_haveSetup) {
+        NSNumber *isExcludedFromBackup =
+            [[NSBundle mainBundle] objectForInfoDictionaryKey:@"RCTAsyncStorageExcludeFromBackup"];
+        if (isExcludedFromBackup == nil) {
+            isExcludedFromBackup = @YES;
+        }
+        RCTAsyncStorageSetExcludedFromBackup(RCTCreateStorageDirectoryPath(RCTStorageDirectory),
+                                             isExcludedFromBackup);
+
+        NSDictionary *errorOut = nil;
+        NSString *serialized = RCTReadFile(RCTCreateStorageDirectoryPath(RCTGetManifestFilePath()),
+                                           RCTManifestFileName,
+                                           &errorOut);
+        if (!serialized) {
+            if (errorOut) {
+                RCTLogError(
+                    @"Could not open the existing manifest, perhaps data protection is "
+                    @"enabled?\n\n%@",
+                    errorOut);
+                return errorOut;
+            } else {
+                _manifest = [NSMutableDictionary new];
+            }
+        } else {
+            _manifest = RCTJSONParseMutable(serialized, &error);
+            if (!_manifest) {
+                RCTLogError(@"Failed to parse manifest - creating a new one.\n\n%@", error);
+                _manifest = [NSMutableDictionary new];
+            }
+        }
+        _haveSetup = YES;
+    }
+
+    return nil;
+}
+
+- (NSDictionary *)_writeManifest:(NSMutableArray<NSDictionary *> *__autoreleasing *)errors
+{
+    NSError *error;
+    NSString *serialized = RCTJSONStringify(_manifest, &error);
+    [serialized writeToFile:RCTCreateStorageDirectoryPath(RCTGetManifestFilePath())
+                 atomically:YES
+                   encoding:NSUTF8StringEncoding
+                      error:&error];
+    NSDictionary *errorOut;
+    if (error) {
+        errorOut = RCTMakeError(@"Failed to write manifest file.", error, nil);
+        RCTAppendError(errorOut, errors);
+    }
+    return errorOut;
+}
+
+- (NSString *)_getValueForKey:(NSString *)key errorOut:(NSDictionary *__autoreleasing *)errorOut
+{
+    NSString *value = _manifest[key];
+    if (value == (id)kCFNull) {
+        value = [RCTGetCache() objectForKey:key];
+        if (!value) {
+            NSString *filePath = [self _filePathForKey:key];
+            value = RCTReadFile(filePath, key, errorOut);
+            if (value) {
+                [RCTGetCache() setObject:value forKey:key cost:value.length];
+            } else {
+                [_manifest removeObjectForKey:key];
+            }
+        }
+    }
+    return value;
+}
+
+- (NSDictionary *)_writeEntry:(NSArray<NSString *> *)entry changedManifest:(BOOL *)changedManifest
+{
+    if (entry.count != 2) {
+        return RCTMakeAndLogError(
+            @"Entries must be arrays of the form [key: string, value: string], got: ", entry, nil);
+    }
+    NSString *key = entry[0];
+    NSDictionary *errorOut = RCTErrorForKey(key);
+    if (errorOut) {
+        return errorOut;
+    }
+    NSString *value = entry[1];
+    NSString *filePath = [self _filePathForKey:key];
+    NSError *error;
+    if (value.length <= RCTInlineValueThreshold) {
+        if (_manifest[key] == (id)kCFNull) {
+            [[NSFileManager defaultManager] removeItemAtPath:filePath error:nil];
+            [RCTGetCache() removeObjectForKey:key];
+        }
+        *changedManifest = YES;
+        _manifest[key] = value;
+        return nil;
+    }
+    [value writeToFile:filePath atomically:YES encoding:NSUTF8StringEncoding error:&error];
+    [RCTGetCache() setObject:value forKey:key cost:value.length];
+    if (error) {
+        errorOut = RCTMakeError(@"Failed to write value.", error, @{@"key": key});
+    } else if (_manifest[key] != (id)kCFNull) {
+        *changedManifest = YES;
+        _manifest[key] = (id)kCFNull;
+    }
+    return errorOut;
+}
+
+#pragma mark - TurboModule methods
+
+- (void)multiGet:(NSArray<NSString *> *)keys
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject
+{
+    dispatch_async(RCTGetMethodQueue(), ^{
+        NSDictionary *ensureSetupError = [self _ensureSetup];
+        if (ensureSetupError) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   ensureSetupError[@"message"] ?: @"Storage setup failed",
+                   nil);
+            return;
+        }
+
+        NSMutableArray<NSArray *> *result = [NSMutableArray arrayWithCapacity:keys.count];
+        for (NSString *key in keys) {
+            NSDictionary *keyError = RCTErrorForKey(key);
+            if (keyError) {
+                [result addObject:@[RCTNullIfNil(key), (id)kCFNull]];
+            } else {
+                NSDictionary *errorOut = nil;
+                NSString *value = [self _getValueForKey:key errorOut:&errorOut];
+                [result addObject:@[key, RCTNullIfNil(value)]];
+            }
+        }
+        resolve(result);
+    });
+}
+
+- (void)multiSet:(NSArray<NSArray<NSString *> *> *)keyValuePairs
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject
+{
+    dispatch_async(RCTGetMethodQueue(), ^{
+        NSDictionary *ensureSetupError = [self _ensureSetup];
+        if (ensureSetupError) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   ensureSetupError[@"message"] ?: @"Storage setup failed",
+                   nil);
+            return;
+        }
+
+        BOOL changedManifest = NO;
+        NSMutableArray<NSDictionary *> *errors;
+        for (NSArray<NSString *> *entry in keyValuePairs) {
+            NSDictionary *keyError = [self _writeEntry:entry changedManifest:&changedManifest];
+            RCTAppendError(keyError, &errors);
+        }
+        if (changedManifest) {
+            [self _writeManifest:&errors];
+        }
+        if (errors.count > 0) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   @"One or more keys failed to set",
+                   nil);
+        } else {
+            resolve(nil);
+        }
+    });
+}
+
+- (void)multiRemove:(NSArray<NSString *> *)keys
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject
+{
+    dispatch_async(RCTGetMethodQueue(), ^{
+        NSDictionary *ensureSetupError = [self _ensureSetup];
+        if (ensureSetupError) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   ensureSetupError[@"message"] ?: @"Storage setup failed",
+                   nil);
+            return;
+        }
+
+        NSMutableArray<NSDictionary *> *errors;
+        BOOL changedManifest = NO;
+        for (NSString *key in keys) {
+            NSDictionary *keyError = RCTErrorForKey(key);
+            if (!keyError) {
+                if (self->_manifest[key] == (id)kCFNull) {
+                    NSString *filePath = [self _filePathForKey:key];
+                    [[NSFileManager defaultManager] removeItemAtPath:filePath error:nil];
+                    [RCTGetCache() removeObjectForKey:key];
+                }
+                if (self->_manifest[key]) {
+                    changedManifest = YES;
+                    [self->_manifest removeObjectForKey:key];
+                }
+            }
+            RCTAppendError(keyError, &errors);
+        }
+        if (changedManifest) {
+            [self _writeManifest:&errors];
+        }
+        if (errors.count > 0) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   @"One or more keys failed to remove",
+                   nil);
+        } else {
+            resolve(nil);
+        }
+    });
+}
+
+- (void)multiMerge:(NSArray<NSArray<NSString *> *> *)keyValuePairs
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+    dispatch_async(RCTGetMethodQueue(), ^{
+        NSDictionary *ensureSetupError = [self _ensureSetup];
+        if (ensureSetupError) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   ensureSetupError[@"message"] ?: @"Storage setup failed",
+                   nil);
+            return;
+        }
+
+        BOOL changedManifest = NO;
+        NSMutableArray<NSDictionary *> *errors;
+        for (__strong NSArray<NSString *> *entry in keyValuePairs) {
+            NSDictionary *keyError;
+            NSString *value = [self _getValueForKey:entry[0] errorOut:&keyError];
+            if (!keyError) {
+                if (value) {
+                    NSError *jsonError;
+                    NSMutableDictionary *mergedVal = RCTJSONParseMutable(value, &jsonError);
+                    NSDictionary *mergingValue = RCTJSONParse(entry[1], &jsonError);
+                    if (!mergingValue.count || RCTMergeRecursive(mergedVal, mergingValue)) {
+                        entry = @[entry[0], RCTNullIfNil(RCTJSONStringify(mergedVal, NULL))];
+                    }
+                    if (jsonError) {
+                        keyError = RCTJSErrorFromNSError(jsonError);
+                    }
+                }
+                if (!keyError) {
+                    keyError = [self _writeEntry:entry changedManifest:&changedManifest];
+                }
+            }
+            RCTAppendError(keyError, &errors);
+        }
+        if (changedManifest) {
+            [self _writeManifest:&errors];
+        }
+        if (errors.count > 0) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   @"One or more keys failed to merge",
+                   nil);
+        } else {
+            resolve(nil);
+        }
+    });
+}
+
+- (void)getAllKeys:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject
+{
+    dispatch_async(RCTGetMethodQueue(), ^{
+        NSDictionary *ensureSetupError = [self _ensureSetup];
+        if (ensureSetupError) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   ensureSetupError[@"message"] ?: @"Storage setup failed",
+                   nil);
+            return;
+        }
+        resolve(self->_manifest.allKeys);
+    });
+}
+
+- (void)clear:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject
+{
+    dispatch_async(RCTGetMethodQueue(), ^{
+        [self->_manifest removeAllObjects];
+        [RCTGetCache() removeAllObjects];
+        NSDictionary *error = RCTDeleteStorageDirectory();
+        if (error) {
+            reject(@"ASYNC_STORAGE_ERROR",
+                   error[@"message"] ?: @"Failed to clear storage",
+                   nil);
+        } else {
+            resolve(nil);
+        }
+    });
+}
+
+@end

package/lib/module/NativeAsyncStorage.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('RNCAsyncStorage');
+//# sourceMappingURL=NativeAsyncStorage.js.map

package/lib/module/NativeAsyncStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeAsyncStorage.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAAQ,cAAc;AAYlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,iBAAiB,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import NativeAsyncStorage from "./NativeAsyncStorage.js";
+export default NativeAsyncStorage;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeAsyncStorage"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,kBAAkB,MAAM,yBAAsB;AAErD,eAAeA,kBAAkB","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,12 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    multiGet(keys: string[]): Promise<[string, string | null][]>;
+    multiSet(keyValuePairs: [string, string][]): Promise<void>;
+    multiRemove(keys: string[]): Promise<void>;
+    multiMerge(keyValuePairs: [string, string][]): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+    clear(): Promise<void>;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeAsyncStorage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAsyncStorage.d.ts","sourceRoot":"","sources":["../../../src/NativeAsyncStorage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;IAC7D,QAAQ,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,UAAU,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7D,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAChC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;;AAED,wBAAyE"}

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

@@ -0,0 +1,4 @@
+import NativeAsyncStorage from './NativeAsyncStorage';
+export default NativeAsyncStorage;
+export type { Spec as AsyncStorageSpec } from './NativeAsyncStorage';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,MAAM,sBAAsB,CAAC;AAEtD,eAAe,kBAAkB,CAAC;AAClC,YAAY,EAAE,IAAI,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC"}

package/package.json

@@ -0,0 +1,155 @@
+{
+  "name": "@onekeyfe/react-native-async-storage",
+  "version": "1.1.55",
+  "description": "react-native-async-storage",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "ios",
+    "*.podspec",
+    "!ios/build",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "clean": "del-cli ios/build lib",
+    "prepare": "bob build",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "test": "jest",
+    "release": "yarn prepare && npm whoami && npm publish --access public"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "async-storage"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneKeyHQ/app-modules/react-native-async-storage.git"
+  },
+  "author": "@onekeyhq <huanming@onekey.so> (https://github.com/OneKeyHQ/app-modules)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/OneKeyHQ/app-modules/react-native-async-storage/issues"
+  },
+  "homepage": "https://github.com/OneKeyHQ/app-modules/react-native-async-storage#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/compat": "^1.3.2",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@react-native/babel-preset": "0.83.0",
+    "@react-native/eslint-config": "0.83.0",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.2.0",
+    "commitlint": "^19.8.1",
+    "del-cli": "^6.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "lefthook": "^2.0.3",
+    "prettier": "^2.8.8",
+    "react": "19.2.0",
+    "react-native": "patch:react-native@npm%3A0.83.0#~/.yarn/patches/react-native-npm-0.83.0-577d0f2d83.patch",
+    "react-native-builder-bob": "^0.40.17",
+    "release-it": "^19.0.4",
+    "turbo": "^2.5.6",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "AsyncStorageSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.asyncstorage"
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "create-react-native-library": {
+    "type": "turbo-module",
+    "languages": "kotlin-objc",
+    "tools": [
+      "eslint",
+      "jest",
+      "lefthook",
+      "release-it"
+    ],
+    "version": "0.56.0"
+  }
+}

package/src/NativeAsyncStorage.ts

@@ -0,0 +1,13 @@
+import { TurboModuleRegistry } from 'react-native';
+import type { TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  multiGet(keys: string[]): Promise<[string, string | null][]>;
+  multiSet(keyValuePairs: [string, string][]): Promise<void>;
+  multiRemove(keys: string[]): Promise<void>;
+  multiMerge(keyValuePairs: [string, string][]): Promise<void>;
+  getAllKeys(): Promise<string[]>;
+  clear(): Promise<void>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNCAsyncStorage');

package/src/index.tsx

@@ -0,0 +1,4 @@
+import NativeAsyncStorage from './NativeAsyncStorage';
+
+export default NativeAsyncStorage;
+export type { Spec as AsyncStorageSpec } from './NativeAsyncStorage';