react-native-compressor 1.8.10 → 1.8.12

package/android/src/main/java/com/reactnativecompressor/Utils/UploaderHelper.kt

@@ -0,0 +1,121 @@
+package com.reactnativecompressor.Utils
+
+import com.facebook.react.bridge.ReadableMap
+import okhttp3.RequestBody
+import okio.Buffer
+import okio.BufferedSink
+import okio.ForwardingSink
+import okio.IOException
+import okio.Sink
+import okio.buffer
+
+interface Record
+annotation class Field(val key: String = "")
+interface Enumerable
+
+@FunctionalInterface
+fun interface RequestBodyDecorator {
+  fun decorate(requestBody: RequestBody): RequestBody
+}
+enum class EncodingType(val value: String) : Enumerable {
+  UTF8("utf8"),
+  BASE64("base64")
+}
+
+enum class UploadType(val value: Int) : Enumerable {
+  BINARY_CONTENT(0),
+  MULTIPART(1)
+}
+data class UploaderOptions(
+  val headers: Map<String, String>?,
+  val httpMethod: HttpMethod = HttpMethod.POST,
+  val uploadType: UploadType,
+  val fieldName: String?,
+  val mimeType: String?,
+  val parameters: Map<String, String>?,
+  val uuid:String,
+  val url:String
+) : Record
+
+enum class HttpMethod(val value: String) : Enumerable {
+  POST("POST"),
+  PUT("PUT"),
+  PATCH("PATCH")
+}
+
+internal class UploaderOkHttpNullException :
+  CodedException("okHttpClient is null")
+internal class CookieHandlerNotFoundException :
+  CodedException("Failed to find CookieHandler")
+interface CodedThrowable {
+  val code: String?
+  val message: String?
+}
+abstract class CodedException : Exception, CodedThrowable {
+  constructor(message: String?) : super(message)
+  constructor(cause: Throwable?) : super(cause)
+  constructor(message: String?, cause: Throwable?) : super(message, cause)
+
+  override val code: String
+    get() = "ERR_UNSPECIFIED_ANDROID_EXCEPTION"
+}
+
+@FunctionalInterface
+interface CountingRequestListener {
+  fun onProgress(bytesWritten: Long, contentLength: Long)
+}
+
+@FunctionalInterface
+
+
+private class CountingSink(
+  sink: Sink,
+  private val requestBody: RequestBody,
+  private val progressListener: CountingRequestListener
+) : ForwardingSink(sink) {
+  private var bytesWritten = 0L
+
+  override fun write(source: Buffer, byteCount: Long) {
+    super.write(source, byteCount)
+
+    bytesWritten += byteCount
+    progressListener.onProgress(bytesWritten, requestBody.contentLength())
+  }
+}
+
+class CountingRequestBody(
+  private val requestBody: RequestBody,
+  private val progressListener: CountingRequestListener
+) : RequestBody() {
+  override fun contentType() = requestBody.contentType()
+
+  @Throws(IOException::class)
+  override fun contentLength() = requestBody.contentLength()
+
+  override fun writeTo(sink: BufferedSink) {
+    val countingSink = CountingSink(sink, this, progressListener)
+
+    val bufferedSink = countingSink.buffer()
+    requestBody.writeTo(bufferedSink)
+    bufferedSink.flush()
+  }
+}
+
+
+fun convertReadableMapToUploaderOptions(options: ReadableMap): UploaderOptions {
+  val headers = options.getMap("headers")?.toHashMap() as? Map<String, String>
+  val httpMethod = HttpMethod.valueOf(options.getString("httpMethod") ?: "POST")
+  val uploadTypeInt = options.getInt("uploadType")
+  val uploadType = when (uploadTypeInt) {
+    UploadType.BINARY_CONTENT.value -> UploadType.BINARY_CONTENT
+    UploadType.MULTIPART.value -> UploadType.MULTIPART
+    else -> UploadType.BINARY_CONTENT // Provide a default value or handle the case as needed
+  }
+  val fieldName = options.getString("fieldName")?: "file"
+  val mimeType = options.getString("mimeType")?: ""
+  val parameters = options.getMap("parameters")?.toHashMap() as? Map<String, String>
+  val uuid = options.getString("uuid") ?: ""
+  val url = options.getString("url") ?: ""
+
+  return UploaderOptions(headers, httpMethod, uploadType, fieldName, mimeType, parameters, uuid, url)
+}

package/android/src/main/java/com/reactnativecompressor/Utils/Utils.kt

@@ -15,6 +15,7 @@ import java.io.IOException
 import java.net.HttpURLConnection
 import java.net.URL
 import java.util.UUID
+import java.util.regex.Pattern
 
 object Utils {
     private const val TAG = "react-native-compessor"
@@ -134,6 +135,19 @@ object Utils {
     }
   }
 
+  fun slashifyFilePath(path: String?): String? {
+    return if (path == null) {
+      null
+    } else if (path.startsWith("file:///")) {
+      path
+    }  else if (path.startsWith("/")) {
+      path.replaceFirst("^/+".toRegex(), "file:///")
+    }else {
+      // Ensure leading schema with a triple slash
+      Pattern.compile("^file:/*").matcher(path).replaceAll("file:///")
+    }
+  }
+
   fun addLog(log: String) {
     Log.d(AudioCompressor.TAG,  log)
   }

package/ios/Image/ImageCompressor.swift

@@ -100,20 +100,40 @@ class ImageCompressor {
         }
         return UIImage()
     }
+    
+    static func isCompressedSizeLessThanActualFile(sourceFileUrl: String,compressedFileUrl: String)-> Bool {
+        let sourceVideoURL = URL(string: sourceFileUrl)
+        let sourcefileSize:Double=Utils.getfileSizeInBytes(forURL:sourceVideoURL!)
+        
+        let compressedVideoURL = URL(string: compressedFileUrl)
+        let compressedfileSize:Double=Utils.getfileSizeInBytes(forURL:compressedVideoURL!)
+        
+        if(compressedfileSize<=sourcefileSize)
+        {
+        return true
+        }
+        return false
+    }
 
     
-    static func manualCompress(_ image: UIImage, output: Int, quality: Float, outputExtension: String, isBase64: Bool) -> String {
+    static func writeImage(_ image: UIImage, output: Int, quality: Float, outputExtension: String, isBase64: Bool,disablePngTransparency:Bool,isEnableAutoCompress:Bool,actualImagePath:String)-> String{
         var data: Data
         var exception: NSException?
-
         switch OutputType(rawValue: output)! {
         case .jpg:
             data = image.jpegData(compressionQuality: CGFloat(quality))!
         case .png:
-            data = image.pngData()!
-            data = image.jpegData(compressionQuality: CGFloat(quality))!
-            let compressedImage = UIImage(data: data)
-            data = compressedImage!.pngData()!
+            if(disablePngTransparency)
+            {
+                data = image.jpegData(compressionQuality: CGFloat(quality))!
+                let compressedImage = UIImage(data: data)
+                data = compressedImage!.pngData()!
+            }
+            else
+            {
+                data=image.pngData()!
+            }
+           
         }
 
         if isBase64 {
@@ -123,17 +143,35 @@ class ImageCompressor {
             do {
                 try data.write(to: URL(fileURLWithPath: filePath), options: .atomic)
                 let returnablePath = makeValidUri(filePath)
+                if(isEnableAutoCompress==true)
+                {
+                    if(self.isCompressedSizeLessThanActualFile(sourceFileUrl: actualImagePath,compressedFileUrl: returnablePath))
+                    {
+                        return returnablePath
+                    }
+                    else
+                    {
+                        MediaCache.deleteFile(atPath:returnablePath)
+                        return actualImagePath
+                    }
+                }
+                
                 return returnablePath
+                
             } catch {
                 exception = NSException(name: NSExceptionName(rawValue: "file_error"), reason: "Error writing file", userInfo: nil)
                 exception?.raise()
             }
         }
-
         return ""
     }
 
     
+    static func manualCompress(_ image: UIImage, output: Int, quality: Float, outputExtension: String, isBase64: Bool,disablePngTransparency:Bool,actualImagePath:String) -> String {
+        return writeImage(image, output: output, quality: quality, outputExtension: outputExtension, isBase64: isBase64, disablePngTransparency: disablePngTransparency,isEnableAutoCompress: false,actualImagePath: actualImagePath)
+    }
+
+    
     static func scaleAndRotateImage(_ image: UIImage) -> UIImage {
         if image.imageOrientation == .up {
             return image
@@ -215,7 +253,7 @@ class ImageCompressor {
             let outputExtension = ImageCompressorOptions.getOutputInString(options.output)
             let resizedImage = ImageCompressor.manualResize(_image, maxWidth: options.maxWidth, maxHeight: options.maxHeight)
             let isBase64 = options.returnableOutputType == .rbase64
-            return ImageCompressor.manualCompress(resizedImage, output: options.output.rawValue, quality: options.quality, outputExtension: outputExtension, isBase64: isBase64)
+            return ImageCompressor.manualCompress(resizedImage, output: options.output.rawValue, quality: options.quality, outputExtension: outputExtension, isBase64: isBase64,disablePngTransparency: options.disablePngTransparency,actualImagePath: imagePath)
         } else {
             exception = NSException(name: NSExceptionName(rawValue: "unsupported_value"), reason: "Unsupported value type.", userInfo: nil)
             exception?.raise()
@@ -228,11 +266,11 @@ class ImageCompressor {
     static func autoCompressHandler(_ imagePath: String, options: ImageCompressorOptions) -> String {
         var exception: NSException?
         var image = ImageCompressor.loadImage(imagePath)
-
+        
         if var image = image {
             image = ImageCompressor.scaleAndRotateImage(image)
             let outputExtension = ImageCompressorOptions.getOutputInString(options.output)
-
+            
             var actualHeight = image.size.height
             var actualWidth = image.size.width
             let maxHeight: CGFloat = CGFloat(options.maxHeight)
@@ -240,7 +278,7 @@ class ImageCompressor {
             var imgRatio = actualWidth / actualHeight
             let maxRatio = maxWidth / maxHeight
             let compressionQuality: CGFloat = CGFloat(options.quality)
-
+            
             if actualHeight > maxHeight || actualWidth > maxWidth {
                 if imgRatio < maxRatio {
                     imgRatio = maxHeight / actualHeight
@@ -255,42 +293,16 @@ class ImageCompressor {
                     actualWidth = maxWidth
                 }
             }
-
+            
             let rect = CGRect(x: 0.0, y: 0.0, width: actualWidth, height: actualHeight)
             UIGraphicsBeginImageContext(rect.size)
             image.draw(in: rect)
+            let isBase64 = options.returnableOutputType == .rbase64
+            
             if let img = UIGraphicsGetImageFromCurrentImageContext() {
-                var imageData: Data
-                switch OutputType(rawValue: options.output.rawValue)! {
-                case .jpg:
-                    imageData = img.jpegData(compressionQuality: compressionQuality)!
-                case .png:
-                    imageData = img.jpegData(compressionQuality: compressionQuality)!
-                    let compressedImage = UIImage(data: imageData)
-                    imageData = compressedImage!.pngData()!
-                }
-
-                UIGraphicsEndImageContext()
-                let isBase64 = options.returnableOutputType == .rbase64
-                if isBase64 {
-                    return imageData.base64EncodedString(options: [])
-                } else {
-                    let filePath = Utils.generateCacheFilePath(outputExtension)
-                    do {
-                        try imageData.write(to: URL(fileURLWithPath: filePath), options: .atomic)
-                        let returnablePath = ImageCompressor.makeValidUri(filePath)
-                        return returnablePath
-                    } catch {
-                        exception = NSException(name: NSExceptionName(rawValue: "file_error"), reason: "Error writing file", userInfo: nil)
-                        exception?.raise()
-                    }
-                }
+                return writeImage(img, output: options.output.rawValue, quality: Float(compressionQuality), outputExtension: outputExtension, isBase64: isBase64, disablePngTransparency: options.disablePngTransparency,isEnableAutoCompress: true,actualImagePath: imagePath)
             }
-        } else {
-            exception = NSException(name: NSExceptionName(rawValue: "unsupported_value"), reason: "Unsupported value type.", userInfo: nil)
-            exception?.raise()
         }
-
         return ""
     }
     

package/ios/Image/ImageCompressorOptions.swift

@@ -44,6 +44,8 @@ class ImageCompressorOptions: NSObject {
                 options.parseReturnableOutput(value as? String)
             case "uuid":
                 options.uuid = value as? String
+            case "disablePngTransparency":
+                options.disablePngTransparency = value as? Bool ?? false
             default:
                 break
             }
@@ -65,6 +67,7 @@ class ImageCompressorOptions: NSObject {
     var output: OutputType = .jpg
     var returnableOutputType: ReturnableOutputType = .ruri
     var uuid: String?
+    var disablePngTransparency: Bool = false
     
     override init() {
         super.init()

package/ios/Utils/MediaCache.swift

@@ -45,4 +45,24 @@ class MediaCache {
             completedImagePaths.removeAll()
         }
     }
+    
+    class func deleteFile(atPath filePath: String) {
+        let fileManager = FileManager.default
+        var _filePath = filePath
+        if _filePath.hasPrefix("file://") {
+            _filePath = _filePath.replacingOccurrences(of: "file://", with: "")
+       }
+        
+        if fileManager.fileExists(atPath: _filePath) {
+            do {
+                try fileManager.removeItem(atPath: _filePath)
+                print("File deleted successfully: \(_filePath)")
+            } catch {
+                print("Error deleting file: \(error.localizedDescription)")
+            }
+        } else {
+            print("File not found at path: \(_filePath)")
+        }
+    }
+
 }

package/ios/Utils/Uploader.swift

@@ -6,6 +6,13 @@
 //
 
 import Foundation
+import MobileCoreServices
+
+enum UploaderUploadType: Int {
+    case UploaderInvalidType = -1
+    case UploaderBinaryContent = 0
+    case UploaderMultipart = 1
+}
 
 struct UploadError: Error {
   private let message: String
@@ -44,11 +51,19 @@ class Uploader : NSObject, URLSessionTaskDelegate{
         return
       }
 
-      guard let file = URL(string: fileUrl) else{
+      guard let localFile = URL(string: fileUrl) else{
         let uploadError = UploadError(message: "invalid file url")
         reject("Failed", "Upload Failed", uploadError)
         return
       }
+        
+      let fieldName = options["fieldName"] as? String ?? "file"
+      let mimeType = options["mimeType"] as? String ?? ""
+      
+      let parameters = options["parameters"] as? [String: String]
+        
+      let uploadType = options["uploadType"] as? Int ?? 0
+          
 
       let headers = options["headers"] as? [String: String] ?? [:]
 
@@ -61,11 +76,30 @@ class Uploader : NSObject, URLSessionTaskDelegate{
 
       uploadResolvers[uuid] = resolve
       uploadRejectors[uuid] = reject
-      // TODO: ADD Headers
+        
+      let type:UploaderUploadType=self.getUploadType(from: uploadType)
+ 
       let config = URLSessionConfiguration.background(withIdentifier: uuid)
       let session = URLSession(configuration: config, delegate: self, delegateQueue: nil)
-      let task = session.uploadTask(with: request, fromFile: file)
-      task.resume()
+        var task:URLSessionUploadTask!;
+        if type == .UploaderBinaryContent {
+            task = session.uploadTask(with: request, fromFile: localFile)
+        } else if type == .UploaderMultipart {
+            let boundaryString = UUID().uuidString
+            let data = try? createMultipartBody(boundary: boundaryString, sourceUrl:localFile,parameters:parameters,fieldName:fieldName,mimeType:mimeType)
+
+                request.setValue("multipart/form-data; boundary=\(boundaryString)", forHTTPHeaderField: "Content-Type")
+                request.httpBody = data
+
+              task=session.uploadTask(withStreamedRequest: request)
+        }
+        else {
+            let errorMessage = String(format: "Invalid upload type: '%@'.", options["uploadType"] as? String ?? "")
+            reject("ERR_FILESYSTEM_INVALID_UPLOAD_TYPE", errorMessage, nil)
+        }
+        
+        task.resume()
+     
     }
 
     func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
@@ -96,4 +130,89 @@ class Uploader : NSObject, URLSessionTaskDelegate{
       guard let uuid = session.configuration.identifier else {return}
         EventEmitterHandler.emituploadProgress(uuid,totalBytesSent: totalBytesSent,totalBytesExpectedToSend: totalBytesExpectedToSend)
     }
+    
+    func headersForMultipartParams(_ params: [String: String]?, boundary: String) -> String {
+      guard let params else {
+        return ""
+      }
+      return params.map { (key: String, value: String) in
+    """
+    --\(boundary)
+    Content-Disposition: form-data; name="\(key)"
+
+    \(value)
+    """
+      }
+      .joined()
+    }
+    
+    func createMultipartBody(boundary: String, sourceUrl: URL, parameters: [String: String]? = nil, fieldName: String? = nil, mimeType: String? = nil) throws -> Data {
+        var body = Data()
+
+        // Add boundary
+        let boundaryPrefix = "--\(boundary)\r\n"
+        body.append(boundaryPrefix.data(using: .utf8)!)
+
+        // Add content disposition for the file
+        var contentDisposition = "Content-Disposition: form-data; name=\"file\"; filename=\"\(sourceUrl.lastPathComponent)\"\r\n"
+        if let fieldName = fieldName {
+            contentDisposition = "Content-Disposition: form-data; name=\"\(fieldName)\"; filename=\"\(sourceUrl.lastPathComponent)\"\r\n"
+        }
+        body.append(contentDisposition.data(using: .utf8)!)
+
+        // Add optional MIME type
+        if let mimeType = mimeType {
+            let contentType = "Content-Type: \(mimeType)\r\n"
+            body.append(contentType.data(using: .utf8)!)
+        }
+
+        // Add blank line
+        body.append("\r\n".data(using: .utf8)!)
+
+        // Add file data
+        let fileData = try Data(contentsOf: sourceUrl)
+        body.append(fileData)
+
+        // Add parameters, if any
+        if let parameters = parameters {
+            for (key, value) in parameters {
+                body.append("\r\n".data(using: .utf8)!)
+                body.append(boundaryPrefix.data(using: .utf8)!)
+                let parameterContentDisposition = "Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n"
+                body.append(parameterContentDisposition.data(using: .utf8)!)
+                body.append(value.data(using: .utf8)!)
+            }
+        }
+
+        // Add closing boundary
+        let closingBoundary = "\r\n--\(boundary)--\r\n"
+        body.append(closingBoundary.data(using: .utf8)!)
+
+        return body
+    }
+    
+    func findMimeType(forAttachment attachment: URL) -> String {
+      if let identifier = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, attachment.pathExtension as CFString, nil)?.takeRetainedValue() {
+        if let type = UTTypeCopyPreferredTagWithClass(identifier, kUTTagClassMIMEType)?.takeRetainedValue() {
+          return type as String
+        }
+      }
+      return "application/octet-stream"
+    }
+    
+    func getUploadType(from type: Int?) -> UploaderUploadType {
+        guard let typeValue = type else {
+            return .UploaderInvalidType
+        }
+        
+        switch typeValue {
+        case UploaderUploadType.UploaderBinaryContent.rawValue,
+            UploaderUploadType.UploaderMultipart.rawValue:
+            return UploaderUploadType(rawValue: typeValue) ?? .UploaderInvalidType
+        default:
+            return .UploaderInvalidType
+        }
+    }
+
+    
 }

package/ios/Utils/Utils.swift

@@ -107,4 +107,24 @@ class Utils {
         }
     }
     
+    static func getfileSizeInBytes(forURL url: Any) -> Double {
+        var fileURL: URL?
+        var fileSize: Double = 0.0
+        if (url is URL) || (url is String)
+        {
+            if (url is URL) {
+                fileURL = url as? URL
+            }
+            else {
+                fileURL = URL(fileURLWithPath: url as! String)
+            }
+            var fileSizeValue = 0.0
+            try? fileSizeValue = (fileURL?.resourceValues(forKeys: [URLResourceKey.fileSizeKey]).allValues.first?.value as! Double?)!
+            if fileSizeValue > 0.0 {
+                fileSize = Double(fileSizeValue)
+            }
+        }
+        return fileSize
+    }
+    
 }

package/lib/commonjs/Image/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_Main","require","_utils","_reactNative","base64UrlRegex","ImageCompressEventEmitter","NativeEventEmitter","Compressor","NativeImage","Image","compress","value","options","arguments","length","undefined","Error","subscription","downloadProgress","uuid","uuidv4","addListener","event","data","progress","cleanData","replace","image_compress","remove","_default","exports","default"],"sourceRoot":"../../../src","sources":["Image/index.tsx"],"mappings":";;;;;;AAAA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAGA,IAAAE,YAAA,GAAAF,OAAA;AAFA,MAAMG,cAAc,GAAG,6CAA6C;AAmDpE,MAAMC,yBAAyB,GAAG,IAAIC,+BAAkB,CAACC,gBAAU,CAAC;AAEpE,MAAMC,WAAW,GAAGD,gBAAU;AAM9B,MAAME,KAAgB,GAAG;EACvBC,QAAQ,EAAE,eAAAA,CAAOC,KAAK,EAAmB;IAAA,IAAjBC,OAAO,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IAClC,IAAI,CAACF,KAAK,EAAE;MACV,MAAM,IAAIK,KAAK,CACb,qEACF,CAAC;IACH;IAEA,IAAIC,YAAqC;IACzC,IAAI;MACF,IAAIL,OAAO,aAAPA,OAAO,eAAPA,OAAO,CAAEM,gBAAgB,EAAE;QAC7B,MAAMC,IAAI,GAAG,IAAAC,aAAM,EAAC,CAAC;QACrB;QACAR,OAAO,CAACO,IAAI,GAAGA,IAAI;QACnBF,YAAY,GAAGZ,yBAAyB,CAACgB,WAAW,CAClD,kBAAkB,EACjBC,KAAU,IAAK;UACd,IAAIA,KAAK,CAACH,IAAI,KAAKA,IAAI,EAAE;YACvBP,OAAO,CAACM,gBAAgB,IACtBN,OAAO,CAACM,gBAAgB,CAACI,KAAK,CAACC,IAAI,CAACC,QAAQ,CAAC;UACjD;QACF,CACF,CAAC;MACH;MAEA,MAAMC,SAAS,GAAGd,KAAK,CAACe,OAAO,CAACtB,cAAc,EAAE,EAAE,CAAC;MACnD,OAAO,MAAMI,WAAW,CAACmB,cAAc,CAACF,SAAS,EAAEb,OAAO,CAAC;IAC7D,CAAC,SAAS;MACR;MACA,IAAIK,YAAY,EAAE;QAChBA,YAAY,CAACW,MAAM,CAAC,CAAC;MACvB;IACF;EACF;AACF,CAAC;AAAC,IAAAC,QAAA,GAEapB,KAAK;AAAAqB,OAAA,CAAAC,OAAA,GAAAF,QAAA"}
+{"version":3,"names":["_Main","require","_utils","_reactNative","base64UrlRegex","ImageCompressEventEmitter","NativeEventEmitter","Compressor","NativeImage","Image","compress","value","options","arguments","length","undefined","Error","subscription","downloadProgress","uuid","uuidv4","addListener","event","data","progress","cleanData","replace","image_compress","remove","_default","exports","default"],"sourceRoot":"../../../src","sources":["Image/index.tsx"],"mappings":";;;;;;AAAA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAGA,IAAAE,YAAA,GAAAF,OAAA;AAFA,MAAMG,cAAc,GAAG,6CAA6C;AAuDpE,MAAMC,yBAAyB,GAAG,IAAIC,+BAAkB,CAACC,gBAAU,CAAC;AAEpE,MAAMC,WAAW,GAAGD,gBAAU;AAM9B,MAAME,KAAgB,GAAG;EACvBC,QAAQ,EAAE,eAAAA,CAAOC,KAAK,EAAmB;IAAA,IAAjBC,OAAO,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IAClC,IAAI,CAACF,KAAK,EAAE;MACV,MAAM,IAAIK,KAAK,CACb,qEACF,CAAC;IACH;IAEA,IAAIC,YAAqC;IACzC,IAAI;MACF,IAAIL,OAAO,aAAPA,OAAO,eAAPA,OAAO,CAAEM,gBAAgB,EAAE;QAC7B,MAAMC,IAAI,GAAG,IAAAC,aAAM,EAAC,CAAC;QACrB;QACAR,OAAO,CAACO,IAAI,GAAGA,IAAI;QACnBF,YAAY,GAAGZ,yBAAyB,CAACgB,WAAW,CAClD,kBAAkB,EACjBC,KAAU,IAAK;UACd,IAAIA,KAAK,CAACH,IAAI,KAAKA,IAAI,EAAE;YACvBP,OAAO,CAACM,gBAAgB,IACtBN,OAAO,CAACM,gBAAgB,CAACI,KAAK,CAACC,IAAI,CAACC,QAAQ,CAAC;UACjD;QACF,CACF,CAAC;MACH;MAEA,MAAMC,SAAS,GAAGd,KAAK,CAACe,OAAO,CAACtB,cAAc,EAAE,EAAE,CAAC;MACnD,OAAO,MAAMI,WAAW,CAACmB,cAAc,CAACF,SAAS,EAAEb,OAAO,CAAC;IAC7D,CAAC,SAAS;MACR;MACA,IAAIK,YAAY,EAAE;QAChBA,YAAY,CAACW,MAAM,CAAC,CAAC;MACvB;IACF;EACF;AACF,CAAC;AAAC,IAAAC,QAAA,GAEapB,KAAK;AAAAqB,OAAA,CAAAC,OAAA,GAAAF,QAAA"}

package/lib/commonjs/index.js

@@ -15,6 +15,18 @@ Object.defineProperty(exports, "Image", {
     return _Image.default;
   }
 });
+Object.defineProperty(exports, "UploadType", {
+  enumerable: true,
+  get: function () {
+    return _utils.UploadType;
+  }
+});
+Object.defineProperty(exports, "UploaderHttpMethod", {
+  enumerable: true,
+  get: function () {
+    return _utils.UploaderHttpMethod;
+  }
+});
 Object.defineProperty(exports, "Video", {
   enumerable: true,
   get: function () {
@@ -100,7 +112,9 @@ var _default = {
   backgroundUpload: _utils.backgroundUpload,
   createVideoThumbnail: _utils.createVideoThumbnail,
   clearCache: _utils.clearCache,
-  download: _utils.download
+  download: _utils.download,
+  UploadType: _utils.UploadType,
+  UploaderHttpMethod: _utils.UploaderHttpMethod
 };
 exports.default = _default;
 //# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_Video","_interopRequireDefault","require","_Audio","_Image","_utils","obj","__esModule","default","_default","Video","Audio","Image","getDetails","uuidv4","generateFilePath","getRealPath","getVideoMetaData","getFileSize","backgroundUpload","createVideoThumbnail","clearCache","download","exports"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,MAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AAWiB,SAAAD,uBAAAK,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,IAAAG,QAAA,GAmBF;EACbC,KAAK,EAALA,cAAK;EACLC,KAAK,EAALA,cAAK;EACLC,KAAK,EAALA,cAAK;EACLC,UAAU,EAAVA,iBAAU;EACVC,MAAM,EAANA,aAAM;EACNC,gBAAgB,EAAhBA,uBAAgB;EAChBC,WAAW,EAAXA,kBAAW;EACXC,gBAAgB,EAAhBA,uBAAgB;EAChBC,WAAW,EAAXA,kBAAW;EACXC,gBAAgB,EAAhBA,uBAAgB;EAChBC,oBAAoB,EAApBA,2BAAoB;EACpBC,UAAU,EAAVA,iBAAU;EACVC,QAAQ,EAARA;AACF,CAAC;AAAAC,OAAA,CAAAf,OAAA,GAAAC,QAAA"}
+{"version":3,"names":["_Video","_interopRequireDefault","require","_Audio","_Image","_utils","obj","__esModule","default","_default","Video","Audio","Image","getDetails","uuidv4","generateFilePath","getRealPath","getVideoMetaData","getFileSize","backgroundUpload","createVideoThumbnail","clearCache","download","UploadType","UploaderHttpMethod","exports"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,MAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AAaiB,SAAAD,uBAAAK,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,IAAAG,QAAA,GAqBF;EACbC,KAAK,EAALA,cAAK;EACLC,KAAK,EAALA,cAAK;EACLC,KAAK,EAALA,cAAK;EACLC,UAAU,EAAVA,iBAAU;EACVC,MAAM,EAANA,aAAM;EACNC,gBAAgB,EAAhBA,uBAAgB;EAChBC,WAAW,EAAXA,kBAAW;EACXC,gBAAgB,EAAhBA,uBAAgB;EAChBC,WAAW,EAAXA,kBAAW;EACXC,gBAAgB,EAAhBA,uBAAgB;EAChBC,oBAAoB,EAApBA,2BAAoB;EACpBC,UAAU,EAAVA,iBAAU;EACVC,QAAQ,EAARA,eAAQ;EACRC,UAAU,EAAVA,iBAAU;EACVC,kBAAkB,EAAlBA;AACF,CAAC;AAAAC,OAAA,CAAAjB,OAAA,GAAAC,QAAA"}

package/lib/commonjs/utils/Uploader.js

@@ -3,11 +3,24 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.backgroundUpload = void 0;
+exports.backgroundUpload = exports.UploaderHttpMethod = exports.UploadType = void 0;
 var _reactNative = require("react-native");
 var _Main = require("../Main");
 var _ = require(".");
 const CompressEventEmitter = new _reactNative.NativeEventEmitter(_Main.Compressor);
+let UploadType = /*#__PURE__*/function (UploadType) {
+  UploadType[UploadType["BINARY_CONTENT"] = 0] = "BINARY_CONTENT";
+  UploadType[UploadType["MULTIPART"] = 1] = "MULTIPART";
+  return UploadType;
+}({});
+exports.UploadType = UploadType;
+let UploaderHttpMethod = /*#__PURE__*/function (UploaderHttpMethod) {
+  UploaderHttpMethod["POST"] = "POST";
+  UploaderHttpMethod["PUT"] = "PUT";
+  UploaderHttpMethod["PATCH"] = "PATCH";
+  return UploaderHttpMethod;
+}({});
+exports.UploaderHttpMethod = UploaderHttpMethod;
 const backgroundUpload = async (url, fileUrl, options, onProgress) => {
   const uuid = (0, _.uuidv4)();
   let subscription;
@@ -26,6 +39,8 @@ const backgroundUpload = async (url, fileUrl, options, onProgress) => {
       uuid,
       method: options.httpMethod,
       headers: options.headers,
+      uploadType: options.uploadType,
+      ...options,
       url
     });
     return result;

package/lib/commonjs/utils/Uploader.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","_Main","_","CompressEventEmitter","NativeEventEmitter","Compressor","backgroundUpload","url","fileUrl","options","onProgress","uuid","uuidv4","subscription","addListener","event","data","written","total","Platform","OS","includes","replace","result","upload","method","httpMethod","headers","remove","exports"],"sourceRoot":"../../../src","sources":["utils/Uploader.tsx"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,IAAAC,KAAA,GAAAD,OAAA;AAEA,IAAAE,CAAA,GAAAF,OAAA;AADA,MAAMG,oBAAoB,GAAG,IAAIC,+BAAkB,CAACC,gBAAU,CAAC;AAuCxD,MAAMC,gBAAgB,GAAG,MAAAA,CAC9BC,GAAW,EACXC,OAAe,EACfC,OAAgC,EAChCC,UAAqD,KACpC;EACjB,MAAMC,IAAI,GAAG,IAAAC,QAAM,EAAC,CAAC;EACrB,IAAIC,YAAqC;EACzC,IAAI;IACF,IAAIH,UAAU,EAAE;MACdG,YAAY,GAAGV,oBAAoB,CAACW,WAAW,CAC7C,gBAAgB,EACfC,KAAU,IAAK;QACd,IAAIA,KAAK,CAACJ,IAAI,KAAKA,IAAI,EAAE;UACvBD,UAAU,CAACK,KAAK,CAACC,IAAI,CAACC,OAAO,EAAEF,KAAK,CAACC,IAAI,CAACE,KAAK,CAAC;QAClD;MACF,CACF,CAAC;IACH;IACA,IAAIC,qBAAQ,CAACC,EAAE,KAAK,SAAS,IAAIZ,OAAO,CAACa,QAAQ,CAAC,SAAS,CAAC,EAAE;MAC5Db,OAAO,GAAGA,OAAO,CAACc,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;IAC1C;IACA,MAAMC,MAAM,GAAG,MAAMlB,gBAAU,CAACmB,MAAM,CAAChB,OAAO,EAAE;MAC9CG,IAAI;MACJc,MAAM,EAAEhB,OAAO,CAACiB,UAAU;MAC1BC,OAAO,EAAElB,OAAO,CAACkB,OAAO;MACxBpB;IACF,CAAC,CAAC;IACF,OAAOgB,MAAM;EACf,CAAC,SAAS;IACR;IACA,IAAIV,YAAY,EAAE;MAChBA,YAAY,CAACe,MAAM,CAAC,CAAC;IACvB;EACF;AACF,CAAC;AAACC,OAAA,CAAAvB,gBAAA,GAAAA,gBAAA"}
+{"version":3,"names":["_reactNative","require","_Main","_","CompressEventEmitter","NativeEventEmitter","Compressor","UploadType","exports","UploaderHttpMethod","backgroundUpload","url","fileUrl","options","onProgress","uuid","uuidv4","subscription","addListener","event","data","written","total","Platform","OS","includes","replace","result","upload","method","httpMethod","headers","uploadType","remove"],"sourceRoot":"../../../src","sources":["utils/Uploader.tsx"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,IAAAC,KAAA,GAAAD,OAAA;AAEA,IAAAE,CAAA,GAAAF,OAAA;AADA,MAAMG,oBAAoB,GAAG,IAAIC,+BAAkB,CAACC,gBAAU,CAAC;AAAC,IAEpDC,UAAU,0BAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAA,OAAVA,UAAU;AAAA;AAAAC,OAAA,CAAAD,UAAA,GAAAA,UAAA;AAAA,IAKVE,kBAAkB,0BAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAA,OAAlBA,kBAAkB;AAAA;AAAAD,OAAA,CAAAC,kBAAA,GAAAA,kBAAA;AA8BvB,MAAMC,gBAAgB,GAAG,MAAAA,CAC9BC,GAAW,EACXC,OAAe,EACfC,OAAwB,EACxBC,UAAqD,KACpC;EACjB,MAAMC,IAAI,GAAG,IAAAC,QAAM,EAAC,CAAC;EACrB,IAAIC,YAAqC;EACzC,IAAI;IACF,IAAIH,UAAU,EAAE;MACdG,YAAY,GAAGb,oBAAoB,CAACc,WAAW,CAC7C,gBAAgB,EACfC,KAAU,IAAK;QACd,IAAIA,KAAK,CAACJ,IAAI,KAAKA,IAAI,EAAE;UACvBD,UAAU,CAACK,KAAK,CAACC,IAAI,CAACC,OAAO,EAAEF,KAAK,CAACC,IAAI,CAACE,KAAK,CAAC;QAClD;MACF,CACF,CAAC;IACH;IACA,IAAIC,qBAAQ,CAACC,EAAE,KAAK,SAAS,IAAIZ,OAAO,CAACa,QAAQ,CAAC,SAAS,CAAC,EAAE;MAC5Db,OAAO,GAAGA,OAAO,CAACc,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;IAC1C;IACA,MAAMC,MAAM,GAAG,MAAMrB,gBAAU,CAACsB,MAAM,CAAChB,OAAO,EAAE;MAC9CG,IAAI;MACJc,MAAM,EAAEhB,OAAO,CAACiB,UAAU;MAC1BC,OAAO,EAAElB,OAAO,CAACkB,OAAO;MACxBC,UAAU,EAAEnB,OAAO,CAACmB,UAAU;MAC9B,GAAGnB,OAAO;MACVF;IACF,CAAC,CAAC;IACF,OAAOgB,MAAM;EACf,CAAC,SAAS;IACR;IACA,IAAIV,YAAY,EAAE;MAChBA,YAAY,CAACgB,MAAM,CAAC,CAAC;IACvB;EACF;AACF,CAAC;AAACzB,OAAA,CAAAE,gBAAA,GAAAA,gBAAA"}

package/lib/module/Image/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["Compressor","uuidv4","base64UrlRegex","NativeEventEmitter","ImageCompressEventEmitter","NativeImage","Image","compress","value","options","arguments","length","undefined","Error","subscription","downloadProgress","uuid","addListener","event","data","progress","cleanData","replace","image_compress","remove"],"sourceRoot":"../../../src","sources":["Image/index.tsx"],"mappings":"AAAA,SAASA,UAAU,QAAQ,SAAS;AACpC,SAASC,MAAM,QAAQ,UAAU;AACjC,MAAMC,cAAc,GAAG,6CAA6C;AAEpE,SAASC,kBAAkB,QAAQ,cAAc;AAiDjD,MAAMC,yBAAyB,GAAG,IAAID,kBAAkB,CAACH,UAAU,CAAC;AAEpE,MAAMK,WAAW,GAAGL,UAAU;AAM9B,MAAMM,KAAgB,GAAG;EACvBC,QAAQ,EAAE,eAAAA,CAAOC,KAAK,EAAmB;IAAA,IAAjBC,OAAO,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IAClC,IAAI,CAACF,KAAK,EAAE;MACV,MAAM,IAAIK,KAAK,CACb,qEACF,CAAC;IACH;IAEA,IAAIC,YAAqC;IACzC,IAAI;MACF,IAAIL,OAAO,aAAPA,OAAO,eAAPA,OAAO,CAAEM,gBAAgB,EAAE;QAC7B,MAAMC,IAAI,GAAGf,MAAM,CAAC,CAAC;QACrB;QACAQ,OAAO,CAACO,IAAI,GAAGA,IAAI;QACnBF,YAAY,GAAGV,yBAAyB,CAACa,WAAW,CAClD,kBAAkB,EACjBC,KAAU,IAAK;UACd,IAAIA,KAAK,CAACF,IAAI,KAAKA,IAAI,EAAE;YACvBP,OAAO,CAACM,gBAAgB,IACtBN,OAAO,CAACM,gBAAgB,CAACG,KAAK,CAACC,IAAI,CAACC,QAAQ,CAAC;UACjD;QACF,CACF,CAAC;MACH;MAEA,MAAMC,SAAS,GAAGb,KAAK,CAACc,OAAO,CAACpB,cAAc,EAAE,EAAE,CAAC;MACnD,OAAO,MAAMG,WAAW,CAACkB,cAAc,CAACF,SAAS,EAAEZ,OAAO,CAAC;IAC7D,CAAC,SAAS;MACR;MACA,IAAIK,YAAY,EAAE;QAChBA,YAAY,CAACU,MAAM,CAAC,CAAC;MACvB;IACF;EACF;AACF,CAAC;AAED,eAAelB,KAAK"}
+{"version":3,"names":["Compressor","uuidv4","base64UrlRegex","NativeEventEmitter","ImageCompressEventEmitter","NativeImage","Image","compress","value","options","arguments","length","undefined","Error","subscription","downloadProgress","uuid","addListener","event","data","progress","cleanData","replace","image_compress","remove"],"sourceRoot":"../../../src","sources":["Image/index.tsx"],"mappings":"AAAA,SAASA,UAAU,QAAQ,SAAS;AACpC,SAASC,MAAM,QAAQ,UAAU;AACjC,MAAMC,cAAc,GAAG,6CAA6C;AAEpE,SAASC,kBAAkB,QAAQ,cAAc;AAqDjD,MAAMC,yBAAyB,GAAG,IAAID,kBAAkB,CAACH,UAAU,CAAC;AAEpE,MAAMK,WAAW,GAAGL,UAAU;AAM9B,MAAMM,KAAgB,GAAG;EACvBC,QAAQ,EAAE,eAAAA,CAAOC,KAAK,EAAmB;IAAA,IAAjBC,OAAO,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IAClC,IAAI,CAACF,KAAK,EAAE;MACV,MAAM,IAAIK,KAAK,CACb,qEACF,CAAC;IACH;IAEA,IAAIC,YAAqC;IACzC,IAAI;MACF,IAAIL,OAAO,aAAPA,OAAO,eAAPA,OAAO,CAAEM,gBAAgB,EAAE;QAC7B,MAAMC,IAAI,GAAGf,MAAM,CAAC,CAAC;QACrB;QACAQ,OAAO,CAACO,IAAI,GAAGA,IAAI;QACnBF,YAAY,GAAGV,yBAAyB,CAACa,WAAW,CAClD,kBAAkB,EACjBC,KAAU,IAAK;UACd,IAAIA,KAAK,CAACF,IAAI,KAAKA,IAAI,EAAE;YACvBP,OAAO,CAACM,gBAAgB,IACtBN,OAAO,CAACM,gBAAgB,CAACG,KAAK,CAACC,IAAI,CAACC,QAAQ,CAAC;UACjD;QACF,CACF,CAAC;MACH;MAEA,MAAMC,SAAS,GAAGb,KAAK,CAACc,OAAO,CAACpB,cAAc,EAAE,EAAE,CAAC;MACnD,OAAO,MAAMG,WAAW,CAACkB,cAAc,CAACF,SAAS,EAAEZ,OAAO,CAAC;IAC7D,CAAC,SAAS;MACR;MACA,IAAIK,YAAY,EAAE;QAChBA,YAAY,CAACU,MAAM,CAAC,CAAC;MACvB;IACF;EACF;AACF,CAAC;AAED,eAAelB,KAAK"}

package/lib/module/index.js

@@ -1,10 +1,10 @@
 import Video from './Video';
 import Audio from './Audio';
 import Image from './Image';
-import { getDetails, uuidv4, generateFilePath, getRealPath, getVideoMetaData, getFileSize, backgroundUpload, createVideoThumbnail, download, clearCache } from './utils';
+import { getDetails, uuidv4, generateFilePath, getRealPath, getVideoMetaData, getFileSize, backgroundUpload, createVideoThumbnail, download, clearCache, UploadType, UploaderHttpMethod } from './utils';
 export { Video, Audio, Image, backgroundUpload, download,
 //type
-getDetails, uuidv4, generateFilePath, getRealPath, getVideoMetaData, createVideoThumbnail, clearCache, getFileSize };
+getDetails, uuidv4, generateFilePath, getRealPath, getVideoMetaData, createVideoThumbnail, clearCache, getFileSize, UploadType, UploaderHttpMethod };
 export default {
   Video,
   Audio,
@@ -18,6 +18,8 @@ export default {
   backgroundUpload,
   createVideoThumbnail,
   clearCache,
-  download
+  download,
+  UploadType,
+  UploaderHttpMethod
 };
 //# sourceMappingURL=index.js.map