react-native-zip-archive 7.0.2-beta.1 → 7.1.0

package/README.md

@@ -54,12 +54,14 @@ import { MainBundlePath, DocumentDirectoryPath } from 'react-native-fs'
 
 ## API
 
-**`zip(source: string | string[], target: string): Promise<string>`**
+**`zip(source: string | string[], target: string, compressionLevel?: number): Promise<string>`**
 
 > zip source to target
 
 ***NOTE: the string version of source is for folder, the string[] version is for file, so if you want to zip a single file, use zip([file]) instead of zip(file)***
 
+***NOTE: customizing the compression level is not supported on iOS with a files source and will be ignored, use a directory source instead.***
+
 Example
 
 ```js
@@ -75,13 +77,15 @@ zip(sourcePath, targetPath)
 })
 ```
 
-**`zipWithPassword(source: string | string[], target: string, password: string, encryptionType: string): Promise<string>`**
+**`zipWithPassword(source: string | string[], target: string, password: string, encryptionType?: string, compressionLevel?: number): Promise<string>`**
 
 > zip source to target
 
 ***NOTE: the string version of source is for folder, the string[] version is for file, so if you want to zip a single file, use zip([file]) instead of zip(file)***
 
-***NOTE: encryptionType is not supported on iOS yet, so it would be igonred on that platform.***
+***NOTE: On iOS, AES-256 and AES-128 both use AES-256 encryption.***
+
+***NOTE: customizing the compression level is not supported on iOS with a files source and will be ignored, use a directory source instead.***
 
 Example
 

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

@@ -64,7 +64,7 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
       net.lingala.zip4j.ZipFile zipFile = new net.lingala.zip4j.ZipFile(zipFilePath);
       promise.resolve(zipFile.isEncrypted());
     } catch (ZipException ex) {
-      promise.reject(null, String.format("Unable to check for encryption due to: %s", getStackTrace(ex)));
+      promise.reject("RNZipArchiveError", String.format("Unable to check for encryption due to: %s", getStackTrace(ex)));
     }
   }
 
@@ -79,7 +79,7 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
           if (zipFile.isEncrypted()) {
             zipFile.setPassword(password.toCharArray());
           } else {
-            promise.reject(null, String.format("Zip file: %s is not password protected", zipFilePath));
+            promise.reject("RNZipArchiveError", String.format("Zip file: %s is not password protected", zipFilePath));
           }
 
           List fileHeaderList = zipFile.getFileHeaders();
@@ -107,7 +107,7 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
           promise.resolve(Arguments.fromList(extractedFileNames));
         } catch (Exception ex) {
           updateProgress(0, 1, zipFilePath); // force 0%
-          promise.reject(null, String.format("Failed to unzip file, due to: %s", getStackTrace(ex)));
+          promise.reject("RNZipArchiveError", String.format("Failed to unzip file, due to: %s", getStackTrace(ex)));
         }
       }
     }).start();
@@ -122,7 +122,7 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
         try {
           new File(zipFilePath);
         } catch (NullPointerException e) {
-          promise.reject(null, "Couldn't open file " + zipFilePath + ". ");
+          promise.reject("RNZipArchiveError", "Couldn't open file " + zipFilePath + ". ");
           return;
         }
 
@@ -174,7 +174,7 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
           }
         } catch (Exception ex) {
           updateProgress(0, 1, zipFilePath); // force 0%
-          promise.reject(null, "Failed to extract file " + ex.getLocalizedMessage());
+          promise.reject("RNZipArchiveError", "Failed to extract file " + ex.getLocalizedMessage());
         }
       }
     }).start();
@@ -212,7 +212,7 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
             compressedSize = fileDescriptor.getLength();
           }
         } catch (IOException e) {
-          promise.reject(null, String.format("Asset file `%s` could not be opened", assetsPath));
+          promise.reject("RNZipArchiveError", String.format("Asset file `%s` could not be opened", assetsPath));
           return;
         }
 
@@ -274,7 +274,7 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
             throw new Exception(String.format("Couldn't extract %s", assetsPath));
           }
         } catch (Exception ex) {
-          promise.reject(null, ex.getMessage());
+          promise.reject("RNZipArchiveError", ex.getMessage());
           return;
         }
         promise.resolve(destDirectory);
@@ -283,39 +283,37 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
   }
 
   @ReactMethod
-  public void zipFiles(final ReadableArray files, final String destDirectory, final Promise promise) {
-    zip(files.toArrayList(), destDirectory, promise);
+  public void zipFiles(final ReadableArray files, final String destDirectory, final double compressionLevel, final Promise promise) {
+    zip(files.toArrayList(), destDirectory, compressionLevel, promise);
   }
 
   @ReactMethod
-  public void zipFolder(final String folder, final String destFile, final Promise promise) {
+  public void zipFolder(final String folder, final String destFile, final double compressionLevel, final Promise promise) {
     ArrayList<Object> folderAsArrayList = new ArrayList<>();
     folderAsArrayList.add(folder);
-    zip(folderAsArrayList, destFile, promise);
+    zip(folderAsArrayList, destFile, compressionLevel, promise);
   }
 
   @ReactMethod
   public void zipFilesWithPassword(final ReadableArray files, final String destFile, final String password,
-                                   String encryptionMethod, Promise promise) {
-    zipWithPassword(files.toArrayList(), destFile, password, encryptionMethod, promise);
+                                   String encryptionMethod, final double compressionLevel, Promise promise) {
+    zipWithPassword(files.toArrayList(), destFile, password, encryptionMethod, compressionLevel, promise);
   }
 
-
   @ReactMethod
   public void zipFolderWithPassword(final String folder, final String destFile, final String password,
-                                    String encryptionMethod, Promise promise) {
+                                    String encryptionMethod, final double compressionLevel, Promise promise) {
     ArrayList<Object> folderAsArrayList = new ArrayList<>();
     folderAsArrayList.add(folder);
-    zipWithPassword(folderAsArrayList, destFile, password, encryptionMethod, promise);
+    zipWithPassword(folderAsArrayList, destFile, password, encryptionMethod, compressionLevel, promise);
   }
 
   private void zipWithPassword(final ArrayList<Object> filesOrDirectory, final String destFile, final String password,
-                               String encryptionMethod, Promise promise) {
+                               String encryptionMethod, final double compressionLevel, Promise promise) {
     try{
-
       ZipParameters parameters = new ZipParameters();
       parameters.setCompressionMethod(CompressionMethod.DEFLATE);
-      parameters.setCompressionLevel(CompressionLevel.NORMAL);
+      parameters.setCompressionLevel(getCompressionLevel(compressionLevel));
 
       String encParts[] = encryptionMethod.split("-");
 
@@ -338,29 +336,27 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
           Log.d(TAG, "Encryption type not supported default to Standard Encryption");
         }
       } else {
-        promise.reject(null, "Password is empty");
+        promise.reject("RNZipArchiveError", "Password is empty");
       }
 
       processZip(filesOrDirectory, destFile, parameters, promise, password.toCharArray());
 
     } catch (Exception ex) {
-      promise.reject(null, ex.getMessage());
+      promise.reject("RNZipArchiveError", ex.getMessage());
       return;
     }
-
   }
 
-  private void zip(final ArrayList<Object> filesOrDirectory, final String destFile, final Promise promise) {
+  private void zip(final ArrayList<Object> filesOrDirectory, final String destFile, final double compressionLevel, final Promise promise) {
     try{
-
       ZipParameters parameters = new ZipParameters();
       parameters.setCompressionMethod(CompressionMethod.DEFLATE);
-      parameters.setCompressionLevel(CompressionLevel.NORMAL);
+      parameters.setCompressionLevel(getCompressionLevel(compressionLevel));
 
       processZip(filesOrDirectory, destFile, parameters, promise, null);
 
     } catch (Exception ex) {
-      promise.reject(null, ex.getMessage());
+      promise.reject("RNZipArchiveError", ex.getMessage());
       return;
     }
   }
@@ -410,14 +406,14 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
               }
             }
             else {
-              promise.reject(null, "File or folder does not exist");
+              promise.reject("RNZipArchiveError", "File or folder does not exist");
             }
 
             updateProgress(1, 1, destFile); // force 100%
           }
           promise.resolve(destFile);
         } catch (Exception ex) {
-          promise.reject(null, ex.getMessage());
+          promise.reject("RNZipArchiveError", ex.getMessage());
           return;
         }
       }
@@ -473,6 +469,36 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
     return totalSize;
   }
 
+  private static CompressionLevel getCompressionLevel(double compressionLevel) {
+    switch (compressionLevel) {
+      case -1:
+        return CompressionLevel.NORMAL;
+      case 0:
+        return CompressionLevel.NO_COMPRESSION;
+      case 1:
+        return CompressionLevel.FASTEST;
+      case 2:
+        return CompressionLevel.FASTER;
+      case 3:
+        return CompressionLevel.FAST;
+      case 4:
+        return CompressionLevel.MEDIUM_FAST;
+      case 5:
+        return CompressionLevel.NORMAL;
+      case 6:
+        return CompressionLevel.HIGHER;
+      case 7:
+        return CompressionLevel.MAXIMUM;
+      case 8:
+        return CompressionLevel.PRE_ULTRA;
+      case 9:
+        return CompressionLevel.ULTRA;
+      default:
+        Log.w(TAG, "Unsupported compression level: " + compressionLevel + ", defaulting to NORMAL (5)");
+        return CompressionLevel.NORMAL;
+    }
+  }
+
   /**
    * Returns the exception stack trace as a string
    */
@@ -492,5 +518,4 @@ public class RNZipArchiveModule extends ReactContextBaseJavaModule {
   public void removeListeners(Integer count) {
     // Keep: Required for RN built in Event Emitter Calls.
   }
-
 }

package/index.d.ts

@@ -1,13 +1,27 @@
-declare module 'react-native-zip-archive' {
-  enum encryptionMethods {
-    'STANDARD',
-    'AES-128',
-    'AES-256'
+declare module "react-native-zip-archive" {
+  enum EncryptionMethods {
+    STANDARD = "STANDARD",
+    AES_128 = "AES-128",
+    AES_256 = "AES-256",
   }
-  import { NativeEventSubscription } from 'react-native';
+  import { NativeEventSubscription } from "react-native";
+  export const DEFAULT_COMPRESSION: number;
+  export const NO_COMPRESSION: number;
+  export const BEST_SPEED: number;
+  export const BEST_COMPRESSION: number;
   export function isPasswordProtected(source: string): Promise<boolean>;
-  export function zip(source: string | string[], target: string): Promise<string>;
-  export function zipWithPassword(source: string | string[], target: string, password: string, encryptionMethod?: encryptionMethods): Promise<string>;
+  export function zip(
+    source: string | string[],
+    target: string,
+    compressionLevel: number = DEFAULT_COMPRESSION
+  ): Promise<string>;
+  export function zipWithPassword(
+    source: string | string[],
+    target: string,
+    password: string,
+    encryptionMethod?: EncryptionMethods,
+    compressionLevel: number = DEFAULT_COMPRESSION
+  ): Promise<string>;
   export function unzip(source: string, target: string, charset?: string): Promise<string>;
   export function unzipWithPassword(assetPath: string, target: string, password: string): Promise<string>;
   export function unzipAssets(assetPath: string, target: string): Promise<string>;

package/index.js

@@ -9,6 +9,11 @@ const rnzaEmitter = new NativeEventEmitter(RNZipArchive);
 const normalizeFilePath = (path) =>
   path.startsWith("file://") ? path.slice(7) : path;
 
+export const DEFAULT_COMPRESSION = -1;
+export const NO_COMPRESSION = 0;
+export const BEST_SPEED = 1;
+export const BEST_COMPRESSION = 9;
+
 export const unzip = (source, target, charset = "UTF-8") => {
   return RNZipArchive.unzip(
     normalizeFilePath(source),
@@ -16,6 +21,7 @@ export const unzip = (source, target, charset = "UTF-8") => {
     charset
   );
 };
+
 export const isPasswordProtected = (source) => {
   return RNZipArchive.isPasswordProtected(normalizeFilePath(source)).then(
     (isEncrypted) => !!isEncrypted
@@ -34,32 +40,37 @@ export const zipWithPassword = (
   source,
   target,
   password,
-  encryptionMethod = ""
+  encryptionMethod = "",
+  compressionLevel = DEFAULT_COMPRESSION,
 ) => {
   return Array.isArray(source)
     ? RNZipArchive.zipFilesWithPassword(
         source.map(normalizeFilePath),
         normalizeFilePath(target),
         password,
-        encryptionMethod
+        encryptionMethod,
+        compressionLevel
       )
     : RNZipArchive.zipFolderWithPassword(
         normalizeFilePath(source),
         normalizeFilePath(target),
         password,
-        encryptionMethod
+        encryptionMethod,
+        compressionLevel
       );
 };
 
-export const zip = (source, target) => {
+export const zip = (source, target, compressionLevel = DEFAULT_COMPRESSION) => {
   return Array.isArray(source)
     ? RNZipArchive.zipFiles(
         source.map(normalizeFilePath),
-        normalizeFilePath(target)
+        normalizeFilePath(target),
+        compressionLevel
       )
     : RNZipArchive.zipFolder(
         normalizeFilePath(source),
-        normalizeFilePath(target)
+        normalizeFilePath(target),
+        compressionLevel
       );
 };
 

package/ios/RNZipArchive.m

@@ -7,6 +7,7 @@
 //
 
 #import "RNZipArchive.h"
+#import <zlib.h>
 
 #if __has_include(<React/RCTEventDispatcher.h>)
 #import <React/RCTEventDispatcher.h>
@@ -91,12 +92,14 @@ RCT_EXPORT_METHOD(unzipWithPassword:(NSString *)from
     if (success) {
         resolve(destinationPath);
     } else {
-        reject(@"unzip_error", @"unable to unzip", error);
+        NSString *errorMessage = error ? [error localizedDescription] : @"unable to unzip";
+        reject(@"unzip_error", errorMessage, error);
     }
 }
 
 RCT_EXPORT_METHOD(zipFolder:(NSString *)from
                   destinationPath:(NSString *)destinationPath
+                  compressionLevel:(double)compressionLevel
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     self.progress = 0.0;
@@ -106,7 +109,13 @@ RCT_EXPORT_METHOD(zipFolder:(NSString *)from
     BOOL success;
     [self setProgressHandler];
 
-    success = [SSZipArchive createZipFileAtPath:destinationPath withContentsOfDirectory:from keepParentDirectory:NO withPassword:nil andProgressHandler:self.progressHandler];
+    success = [SSZipArchive createZipFileAtPath:destinationPath
+                        withContentsOfDirectory:from
+                            keepParentDirectory:NO
+                               compressionLevel:compressionLevel
+                                       password:nil
+                                            AES:NO
+                                progressHandler:self.progressHandler];
 
     self.progress = 1.0;
     [self zipArchiveProgressEvent:1 total:1]; // force 100%
@@ -121,6 +130,7 @@ RCT_EXPORT_METHOD(zipFolder:(NSString *)from
 
 RCT_EXPORT_METHOD(zipFiles:(NSArray<NSString *> *)from
                   destinationPath:(NSString *)destinationPath
+                  compressionLevel:(double)compressionLevel
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     self.progress = 0.0;
@@ -143,11 +153,11 @@ RCT_EXPORT_METHOD(zipFiles:(NSArray<NSString *> *)from
     }
 }
 
-
 RCT_EXPORT_METHOD(zipFolderWithPassword:(NSString *)from
                   destinationPath:(NSString *)destinationPath
                   password:(NSString *)password
                   encryptionType:(NSString *)encryptionType
+                  compressionLevel:(double)compressionLevel
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     self.progress = 0.0;
@@ -156,7 +166,14 @@ RCT_EXPORT_METHOD(zipFolderWithPassword:(NSString *)from
 
     BOOL success;
     [self setProgressHandler];
-    success = [SSZipArchive createZipFileAtPath:destinationPath withContentsOfDirectory:from keepParentDirectory:NO withPassword:password andProgressHandler:self.progressHandler];
+    BOOL useAES = encryptionType && ![encryptionType isEqualToString:@"STANDARD"];
+    success = [SSZipArchive createZipFileAtPath:destinationPath
+                        withContentsOfDirectory:from
+                            keepParentDirectory:NO
+                               compressionLevel:compressionLevel
+                                       password:password
+                                            AES:useAES
+                                progressHandler:self.progressHandler];
 
     self.progress = 1.0;
     [self zipArchiveProgressEvent:1 total:1]; // force 100%
@@ -173,6 +190,7 @@ RCT_EXPORT_METHOD(zipFilesWithPassword:(NSArray<NSString *> *)from
                   destinationPath:(NSString *)destinationPath
                   password:(NSString *)password
                   encryptionType:(NSString *)encryptionType
+                  compressionLevel:(double)compressionLevel
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     self.progress = 0.0;
@@ -181,6 +199,7 @@ RCT_EXPORT_METHOD(zipFilesWithPassword:(NSArray<NSString *> *)from
 
     BOOL success;
     [self setProgressHandler];
+    // Note: withFilesAtPaths doesn't have AES class method, using password only
     success = [SSZipArchive createZipFileAtPath:destinationPath withFilesAtPaths:from withPassword:password];
 
     self.progress = 1.0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-zip-archive",
-  "version": "7.0.2-beta.1",
+  "version": "7.1.0",
   "description": "A little wrapper on ZipArchive for react-native",
   "main": "index.js",
   "scripts": {