@onekeyfe/react-native-zip-archive 1.1.57

package/ZipArchive.podspec

@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ZipArchive"
+  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-zip-archive.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  s.dependency 'SSZipArchive'
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,77 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['RNZipArchive_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RNZipArchive_" + name]).toInteger()
+}
+
+android {
+  namespace "com.rnziparchive"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/src/main/java/com/rnziparchive/RNZipArchiveModule.kt

@@ -0,0 +1,158 @@
+package com.rnziparchive
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.module.annotations.ReactModule
+import java.io.BufferedInputStream
+import java.io.BufferedOutputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+import java.util.zip.ZipInputStream
+import java.util.zip.ZipOutputStream
+
+@ReactModule(name = RNZipArchiveModule.NAME)
+class RNZipArchiveModule(reactContext: ReactApplicationContext) :
+    NativeRNZipArchiveSpec(reactContext) {
+
+    companion object {
+        const val NAME = "RNZipArchive"
+        private const val BUFFER_SIZE = 8192
+    }
+
+    override fun getName(): String = NAME
+
+    override fun isPasswordProtected(file: String, promise: Promise) {
+        Thread {
+            try {
+                // java.util.zip does not support password-protected zips natively
+                // Return false as a safe default
+                promise.resolve(false)
+            } catch (e: Exception) {
+                promise.reject("ZIP_ERROR", e.message, e)
+            }
+        }.start()
+    }
+
+    override fun unzip(from: String, to: String, promise: Promise) {
+        Thread {
+            try {
+                val destDir = File(to)
+                if (!destDir.exists()) destDir.mkdirs()
+
+                ZipInputStream(BufferedInputStream(FileInputStream(from))).use { zis ->
+                    var entry: ZipEntry? = zis.nextEntry
+                    while (entry != null) {
+                        val outFile = File(destDir, entry.name)
+                        if (entry.isDirectory) {
+                            outFile.mkdirs()
+                        } else {
+                            outFile.parentFile?.mkdirs()
+                            FileOutputStream(outFile).use { fos ->
+                                val buffer = ByteArray(BUFFER_SIZE)
+                                var len: Int
+                                while (zis.read(buffer).also { len = it } > 0) {
+                                    fos.write(buffer, 0, len)
+                                }
+                            }
+                        }
+                        zis.closeEntry()
+                        entry = zis.nextEntry
+                    }
+                }
+                promise.resolve(to)
+            } catch (e: Exception) {
+                promise.reject("ZIP_ERROR", e.message, e)
+            }
+        }.start()
+    }
+
+    override fun unzipWithPassword(from: String, to: String, password: String, promise: Promise) {
+        Thread {
+            // java.util.zip does not support password-protected zip extraction
+            promise.reject("ZIP_ERROR", "Password-protected zip extraction is not supported on Android")
+        }.start()
+    }
+
+    override fun zipFolder(from: String, to: String, promise: Promise) {
+        Thread {
+            try {
+                val sourceDir = File(from)
+                FileOutputStream(to).use { fos ->
+                    ZipOutputStream(BufferedOutputStream(fos)).use { zos ->
+                        zipDirectory(sourceDir, sourceDir.name, zos)
+                    }
+                }
+                promise.resolve(to)
+            } catch (e: Exception) {
+                promise.reject("ZIP_ERROR", e.message, e)
+            }
+        }.start()
+    }
+
+    override fun zipFiles(files: ReadableArray, to: String, promise: Promise) {
+        Thread {
+            try {
+                FileOutputStream(to).use { fos ->
+                    ZipOutputStream(BufferedOutputStream(fos)).use { zos ->
+                        for (i in 0 until files.size()) {
+                            val filePath = files.getString(i)
+                            val file = File(filePath)
+                            if (file.exists()) {
+                                addFileToZip(file, file.name, zos)
+                            }
+                        }
+                    }
+                }
+                promise.resolve(to)
+            } catch (e: Exception) {
+                promise.reject("ZIP_ERROR", e.message, e)
+            }
+        }.start()
+    }
+
+    override fun getUncompressedSize(path: String, promise: Promise) {
+        Thread {
+            try {
+                var totalSize = 0L
+                ZipFile(path).use { zipFile ->
+                    val entries = zipFile.entries()
+                    while (entries.hasMoreElements()) {
+                        totalSize += entries.nextElement().size
+                    }
+                }
+                promise.resolve(totalSize.toDouble())
+            } catch (e: Exception) {
+                promise.reject("ZIP_ERROR", e.message, e)
+            }
+        }.start()
+    }
+
+    private fun zipDirectory(dir: File, baseName: String, zos: ZipOutputStream) {
+        val files = dir.listFiles() ?: return
+        for (file in files) {
+            val entryName = "$baseName/${file.name}"
+            if (file.isDirectory) {
+                zipDirectory(file, entryName, zos)
+            } else {
+                addFileToZip(file, entryName, zos)
+            }
+        }
+    }
+
+    private fun addFileToZip(file: File, entryName: String, zos: ZipOutputStream) {
+        val entry = ZipEntry(entryName)
+        zos.putNextEntry(entry)
+        FileInputStream(file).use { fis ->
+            val buffer = ByteArray(BUFFER_SIZE)
+            var len: Int
+            while (fis.read(buffer).also { len = it } > 0) {
+                zos.write(buffer, 0, len)
+            }
+        }
+        zos.closeEntry()
+    }
+}

package/android/src/main/java/com/rnziparchive/RNZipArchivePackage.kt

@@ -0,0 +1,33 @@
+package com.rnziparchive
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class RNZipArchivePackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == RNZipArchiveModule.NAME) {
+            RNZipArchiveModule(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+            moduleInfos[RNZipArchiveModule.NAME] = ReactModuleInfo(
+                RNZipArchiveModule.NAME,
+                RNZipArchiveModule.NAME,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                false,  // isCxxModule
+                true    // isTurboModule
+            )
+            moduleInfos
+        }
+    }
+}

package/ios/ZipArchive.h

@@ -0,0 +1,10 @@
+#import <RNZipArchiveSpec/RNZipArchiveSpec.h>
+#import <SSZipArchive/SSZipArchive.h>
+
+@interface ZipArchive : NativeRNZipArchiveSpecBase <NativeRNZipArchiveSpec, SSZipArchiveDelegate>
+
+@property (nonatomic) NSString *processedFilePath;
+@property (nonatomic) float progress;
+@property (nonatomic, copy) void (^progressHandler)(NSUInteger entryNumber, NSUInteger total);
+
+@end

package/ios/ZipArchive.mm

@@ -0,0 +1,182 @@
+#import "ZipArchive.h"
+
+@implementation ZipArchive
+{
+    bool hasListeners;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeRNZipArchiveSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+    return @"RNZipArchive";
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (dispatch_queue_t)methodQueue
+{
+    return dispatch_queue_create("com.onekey.ZipArchiveQueue", DISPATCH_QUEUE_SERIAL);
+}
+
+// MARK: - isPasswordProtected
+
+- (void)isPasswordProtected:(NSString *)file
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject
+{
+    BOOL isPasswordProtected = [SSZipArchive isFilePasswordProtectedAtPath:file];
+    resolve([NSNumber numberWithBool:isPasswordProtected]);
+}
+
+// MARK: - unzip
+
+- (void)unzip:(NSString *)from
+           to:(NSString *)to
+      resolve:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject
+{
+    self.progress = 0.0;
+    self.processedFilePath = @"";
+
+    NSError *error = nil;
+    BOOL success = [SSZipArchive unzipFileAtPath:from
+                                  toDestination:to
+                             preserveAttributes:NO
+                                      overwrite:YES
+                                       password:nil
+                                          error:&error
+                                       delegate:self];
+
+    self.progress = 1.0;
+
+    if (success) {
+        resolve(to);
+    } else {
+        reject(@"unzip_error", [error localizedDescription], error);
+    }
+}
+
+// MARK: - unzipWithPassword
+
+- (void)unzipWithPassword:(NSString *)from
+                       to:(NSString *)to
+                 password:(NSString *)password
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject
+{
+    self.progress = 0.0;
+    self.processedFilePath = @"";
+
+    NSError *error = nil;
+    BOOL success = [SSZipArchive unzipFileAtPath:from
+                                  toDestination:to
+                             preserveAttributes:NO
+                                      overwrite:YES
+                                       password:password
+                                          error:&error
+                                       delegate:self];
+
+    self.progress = 1.0;
+
+    if (success) {
+        resolve(to);
+    } else {
+        reject(@"unzip_error", @"unable to unzip", error);
+    }
+}
+
+// MARK: - zipFolder
+
+- (void)zipFolder:(NSString *)from
+               to:(NSString *)to
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject
+{
+    self.progress = 0.0;
+    self.processedFilePath = @"";
+    [self setProgressHandler];
+
+    BOOL success = [SSZipArchive createZipFileAtPath:to
+                             withContentsOfDirectory:from
+                                 keepParentDirectory:NO
+                                       withPassword:nil
+                                  andProgressHandler:self.progressHandler];
+
+    self.progress = 1.0;
+
+    if (success) {
+        resolve(to);
+    } else {
+        reject(@"zip_error", @"unable to zip", nil);
+    }
+}
+
+// MARK: - zipFiles
+
+- (void)zipFiles:(NSArray *)files
+              to:(NSString *)to
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject
+{
+    self.progress = 0.0;
+    self.processedFilePath = @"";
+    [self setProgressHandler];
+
+    BOOL success = [SSZipArchive createZipFileAtPath:to withFilesAtPaths:files];
+
+    self.progress = 1.0;
+
+    if (success) {
+        resolve(to);
+    } else {
+        reject(@"zip_error", @"unable to zip", nil);
+    }
+}
+
+// MARK: - getUncompressedSize
+
+- (void)getUncompressedSize:(NSString *)path
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject
+{
+    NSError *error = nil;
+    NSNumber *wantedFileSize = [SSZipArchive payloadSizeForArchiveAtPath:path error:&error];
+
+    if (error == nil) {
+        resolve(wantedFileSize);
+    } else {
+        resolve(@-1);
+    }
+}
+
+// MARK: - SSZipArchiveDelegate
+
+- (void)zipArchiveDidUnzipFileAtIndex:(NSInteger)fileIndex
+                           totalFiles:(NSInteger)totalFiles
+                          archivePath:(NSString *)archivePath
+                      unzippedFilePath:(NSString *)processedFilePath
+{
+    self.processedFilePath = processedFilePath;
+}
+
+// MARK: - Progress helper
+
+- (void)setProgressHandler
+{
+    __weak ZipArchive *weakSelf = self;
+    self.progressHandler = ^(NSUInteger entryNumber, NSUInteger total) {
+        if (total > 0) {
+            weakSelf.progress = (float)entryNumber / (float)total;
+        }
+    };
+}
+
+@end

package/lib/module/NativeZipArchive.js

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

package/lib/module/NativeZipArchive.js.map

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

package/lib/module/index.js

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

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeZipArchive","ZipArchive"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,gBAAgB,MAAM,uBAAoB;AAEjD,OAAO,MAAMC,UAAU,GAAGD,gBAAgB","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/NativeZipArchive.d.ts

@@ -0,0 +1,12 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    isPasswordProtected(file: string): Promise<boolean>;
+    unzip(from: string, to: string): Promise<string>;
+    unzipWithPassword(from: string, to: string, password: string): Promise<string>;
+    zipFolder(from: string, to: string): Promise<string>;
+    zipFiles(files: string[], to: string): Promise<string>;
+    getUncompressedSize(path: string): Promise<number>;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeZipArchive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeZipArchive.d.ts","sourceRoot":"","sources":["../../../src/NativeZipArchive.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACpD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACjD,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/E,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACvD,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACpD;;AAED,wBAAsE"}

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

@@ -0,0 +1,3 @@
+export declare const ZipArchive: import("./NativeZipArchive").Spec;
+export type { Spec as ZipArchiveSpec } from './NativeZipArchive';
+//# 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":"AAEA,eAAO,MAAM,UAAU,mCAAmB,CAAC;AAC3C,YAAY,EAAE,IAAI,IAAI,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@onekeyfe/react-native-zip-archive",
+  "version": "1.1.57",
+  "description": "react-native-zip-archive TurboModule for OneKey",
+  "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__",
+    "!**/.*",
+    "android"
+  ],
+  "scripts": {
+    "prepare": "bob build",
+    "typecheck": "tsc",
+    "release": "yarn prepare && npm whoami && npm publish --access public"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneKeyHQ/app-modules/react-native-zip-archive.git"
+  },
+  "author": "@onekeyhq <huanming@onekey.so> (https://github.com/OneKeyHQ/app-modules)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/OneKeyHQ/app-modules/react-native-zip-archive/issues"
+  },
+  "homepage": "https://github.com/OneKeyHQ/app-modules/react-native-zip-archive#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "@react-native/babel-preset": "0.83.0",
+    "react": "19.2.0",
+    "react-native": "0.83.0",
+    "react-native-builder-bob": "^0.40.17",
+    "typescript": "^5.9.2"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "RNZipArchiveSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.rnziparchive"
+    }
+  }
+}

package/src/NativeZipArchive.ts

@@ -0,0 +1,13 @@
+import { TurboModuleRegistry } from 'react-native';
+import type { TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  isPasswordProtected(file: string): Promise<boolean>;
+  unzip(from: string, to: string): Promise<string>;
+  unzipWithPassword(from: string, to: string, password: string): Promise<string>;
+  zipFolder(from: string, to: string): Promise<string>;
+  zipFiles(files: string[], to: string): Promise<string>;
+  getUncompressedSize(path: string): Promise<number>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNZipArchive');

package/src/index.tsx

@@ -0,0 +1,4 @@
+import NativeZipArchive from './NativeZipArchive';
+
+export const ZipArchive = NativeZipArchive;
+export type { Spec as ZipArchiveSpec } from './NativeZipArchive';