react-native-compressor 1.8.9 → 1.8.11

package/README.md

@@ -287,6 +287,17 @@ const uploadResult = await backgroundUpload(
     console.log(written, total);
   }
 );
+
+//OR
+
+const uploadResult = await backgroundUpload(
+  url,
+  fileUrl,
+  { uploadType: UploadType.MULTIPART, httpMethod: 'POST', headers },
+  (written, total) => {
+    console.log(written, total);
+  }
+);
 ```
 
 ### Download File
@@ -406,28 +417,50 @@ await clearCache(); // this will clear cache of thumbnails cache directory
 
 ## Background Upload
 
-- ###### backgroundUpload: (url: string, fileUrl: string, options: FileSystemUploadOptions, onProgress?: ((writtem: number, total: number) => void) | undefined) => Promise< any >
+- ###### backgroundUpload: (url: string, fileUrl: string, options: UploaderOptions, onProgress?: ((writtem: number, total: number) => void) | undefined) => Promise< any >
 
-- ###### ` FileSystemUploadOptions`
+- ###### ` UploaderOptions`
 
 ```js
-type FileSystemUploadOptions = (
+export enum UploadType {
+  BINARY_CONTENT = 0,
+  MULTIPART = 1,
+}
+
+export enum UploaderHttpMethod {
+  POST = 'POST',
+  PUT = 'PUT',
+  PATCH = 'PATCH',
+}
+
+export declare type HTTPResponse = {
+  status: number;
+  headers: Record<string, string>;
+  body: string;
+};
+
+export declare type HttpMethod = 'POST' | 'PUT' | 'PATCH';
+
+export declare type UploaderOptions = (
   | {
-      uploadType?: FileSystemUploadType.BINARY_CONTENT,
+      uploadType?: UploadType.BINARY_CONTENT;
+      mimeType?: string;
     }
   | {
-      uploadType: FileSystemUploadType.MULTIPART, // will add soon
-      fieldName?: string, // will add soon
-      mimeType?: string,
-      parameters?: Record<string, string>,
+      uploadType: UploadType.MULTIPART;
+      fieldName?: string;
+      mimeType?: string;
+      parameters?: Record<string, string>;
     }
 ) & {
-  headers?: Record<string, string>,
-  httpMethod?: FileSystemAcceptedUploadHttpMethod,
-  sessionType?: FileSystemSessionType,
+  headers?: Record<string, string>;
+  httpMethod?: UploaderHttpMethod;
 };
 ```
 
+**Note:** some of the uploader code is borrowed from [Expo](https://github.com/expo/expo)
+I tested file uploader on this backend [Nodejs-File-Uploader](https://github.com/numandev1/nodejs-file-uploader)
+
 ### Download
 
 - ##### download: ( fileUrl: string, downloadProgress?: (progress: number) => void, progressDivider?: number ) => Promise< string >

package/android/build.gradle

@@ -115,7 +115,6 @@ dependencies {
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
   implementation "com.googlecode.mp4parser:isoparser:1.0.6"
-  implementation 'io.github.lizhangqu:coreprogress:1.0.2'
   implementation 'com.github.banketree:AndroidLame-kotlin:v0.0.1'
   implementation 'javazoom:jlayer:1.0.1'
 }

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

@@ -15,12 +15,14 @@ import com.reactnativecompressor.Utils.Uploader
 import com.reactnativecompressor.Utils.Utils
 import com.reactnativecompressor.Utils.Utils.generateCacheFilePath
 import com.reactnativecompressor.Utils.Utils.getRealPath
+import com.reactnativecompressor.Utils.convertReadableMapToUploaderOptions
 import com.reactnativecompressor.Video.VideoMain
 
 class CompressorModule(private val reactContext: ReactApplicationContext) : CompressorSpec(reactContext) {
   private val imageMain: ImageMain = ImageMain(reactContext)
   private val videoMain: VideoMain = VideoMain(reactContext)
   private val audioMain: AudioMain = AudioMain(reactContext)
+  private val uploader: Uploader = Uploader(reactContext)
   private val videoThumbnail: CreateVideoThumbnailClass = CreateVideoThumbnailClass(reactContext)
 
   override fun initialize() {
@@ -120,7 +122,7 @@ class CompressorModule(private val reactContext: ReactApplicationContext) : Comp
     fileUrl: String,
     options: ReadableMap,
     promise: Promise) {
-    Uploader.upload(fileUrl, options, reactContext, promise)
+    uploader.upload(fileUrl, options, reactContext, promise)
   }
 
   @ReactMethod

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

@@ -1,117 +1,189 @@
 package com.reactnativecompressor.Utils
 
+import android.annotation.SuppressLint
+import android.content.ContentResolver
+import android.net.Uri
 import android.util.Log
+import android.webkit.MimeTypeMap
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
-import io.github.lizhangqu.coreprogress.ProgressHelper
-import io.github.lizhangqu.coreprogress.ProgressUIListener
 import okhttp3.Call
 import okhttp3.Callback
-import okhttp3.MediaType
+import okhttp3.Headers
 import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.MultipartBody
 import okhttp3.OkHttpClient
-import okhttp3.Request.Builder
+import okhttp3.Request
 import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.asRequestBody
 import okhttp3.Response
 import java.io.File
 import java.io.IOException
-import java.util.Locale
-
-object Uploader {
-    private const val TAG = "asyncTaskUploader"
-
-    fun upload(fileUrl: String, _options: ReadableMap?, reactContext: ReactApplicationContext, promise: Promise) {
-        val options = _options?.let { UploaderHelper.fromMap(it) }
-        val uploadableFile = File(fileUrl)
-        val url = options?.url
-        var contentType: String? = "video"
-        val okHttpClient = OkHttpClient()
-        val builder = Builder()
-      if (url != null) {
-        builder.url(url)
-      }
-        val headerIterator = options?.headers?.keySetIterator()
-        while (headerIterator?.hasNextKey() == true) {
-          val key = headerIterator.nextKey()
-          val value = options.headers?.getString(key)
-          Log.d(TAG, "$key  value: $value")
-          builder.addHeader(key, value.toString())
-          if (key.lowercase(Locale.getDefault()) == "content-type:") {
-            contentType = value
+import java.net.URLConnection
+import java.util.concurrent.TimeUnit
+import java.util.regex.Pattern
+
+class Uploader(private val reactContext: ReactApplicationContext) {
+    val TAG = "asyncTaskUploader"
+    var client: OkHttpClient? = null
+    val MIN_EVENT_DT_MS: Long = 100
+
+    fun upload(fileUriString: String, _options: ReadableMap, reactContext: ReactApplicationContext, promise: Promise) {
+      val options:UploaderOptions=convertReadableMapToUploaderOptions(_options)
+      val url = options.url
+      val uuid = options.uuid
+      val progressListener: CountingRequestListener = object : CountingRequestListener {
+        private var mLastUpdate: Long = -1
+        override fun onProgress(bytesWritten: Long, contentLength: Long) {
+          val currentTime = System.currentTimeMillis()
+
+          // Throttle events. Sending too many events will block the JS event loop.
+          // Make sure to send the last event when we're at 100%.
+          if (currentTime > mLastUpdate + MIN_EVENT_DT_MS || bytesWritten == contentLength) {
+            mLastUpdate = currentTime
+            EventEmitterHandler.sendUploadProgressEvent(bytesWritten,contentLength,uuid)
           }
         }
-        val mediaType: MediaType? = contentType?.toMediaTypeOrNull();
-        val body = RequestBody.create(mediaType, uploadableFile)
-        val requestBody = ProgressHelper.withProgress(body, object : ProgressUIListener() {
-            //if you don't need this method, don't override this methd. It isn't an abstract method, just an empty method.
-            override fun onUIProgressStart(totalBytes: Long) {
-                super.onUIProgressStart(totalBytes)
-                Log.d(TAG, "onUIProgressStart:$totalBytes")
-            }
-
-            override fun onUIProgressChanged(numBytes: Long, totalBytes: Long, percent: Float, speed: Float) {
-                EventEmitterHandler.sendUploadProgressEvent(numBytes,totalBytes,options?.uuid)
-                Log.d(TAG, "=============start===============")
-                Log.d(TAG, "numBytes:$numBytes")
-                Log.d(TAG, "totalBytes:$totalBytes")
-                Log.d(TAG, "percent:$percent")
-                Log.d(TAG, "speed:$speed")
-                Log.d(TAG, "============= end ===============")
-            }
-
-            //if you don't need this method, don't override this methd. It isn't an abstract method, just an empty method.
-            override fun onUIProgressFinish() {
-                super.onUIProgressFinish()
-                Log.d(TAG, "onUIProgressFinish:")
-            }
-        })
-        builder.put(requestBody)
-        val call = okHttpClient.newCall(builder.build())
-        call.enqueue(object : Callback {
-            override fun onFailure(call: Call, e: IOException) {
-                Log.d(TAG, "=============onFailure===============")
-                promise.reject("")
-                e.printStackTrace()
-            }
-
-            @Throws(IOException::class)
-            override fun onResponse(call: Call, response: Response) {
-                Log.d(TAG, "=============onResponse===============")
-                Log.d(TAG, "request headers:" + response.request.headers)
-                Log.d(TAG, "response code:" + response.code)
-                Log.d(TAG, "response headers:" + response.headers)
-                Log.d(TAG, "response body:" + response.body!!.string())
-                val param = Arguments.createMap()
-                param.putInt("status", response.code)
-                promise.resolve(param)
-            }
+      }
+      val request = createUploadRequest(
+        url, fileUriString, options
+      ) { requestBody -> CountingRequestBody(requestBody, progressListener) }
+
+      okHttpClient?.let {
+        it.newCall(request).enqueue(object : Callback {
+          override fun onFailure(call: Call, e: IOException) {
+            Log.e(TAG, e.message.toString())
+            promise.reject(TAG, e.message, e)
+          }
+
+          override fun onResponse(call: Call, response: Response) {
+            val param = Arguments.createMap()
+            param.putInt("status", response.code)
+            param.putString("body", response.body?.string())
+            param.putMap("headers", translateHeaders(response.headers))
+            response.close()
+            promise.resolve(param)
+          }
         })
+      } ?: run {
+        promise.reject(UploaderOkHttpNullException())
+      }
+
     }
-}
 
+  @get:Synchronized
+  private val okHttpClient: OkHttpClient?
+    get() {
+      if (client == null) {
+        val builder = OkHttpClient.Builder()
+          .connectTimeout(60, TimeUnit.SECONDS)
+          .readTimeout(60, TimeUnit.SECONDS)
+          .writeTimeout(60, TimeUnit.SECONDS)
+        client = builder.build()
+      }
+      return client
+    }
 
-class UploaderHelper {
-  var uuid: String? = null
-  var method: String? = null
-  var headers: ReadableMap? = null
-  var url: String? = null
-
-  companion object {
-    fun fromMap(map: ReadableMap): UploaderHelper {
-      val options = UploaderHelper()
-      val iterator = map.keySetIterator()
-      while (iterator.hasNextKey()) {
-        val key = iterator.nextKey()
-        when (key) {
-          "uuid" -> options.uuid = map.getString(key)
-          "method" -> options.method = map.getString(key)
-          "headers" -> options.headers = map.getMap(key)
-          "url" -> options.url = map.getString(key)
+  private fun slashifyFilePath(path: String?): String? {
+    return if (path == null) {
+      null
+    } else if (path.startsWith("file:///")) {
+      path
+    } else {
+      // Ensure leading schema with a triple slash
+      Pattern.compile("^file:/*").matcher(path).replaceAll("file:///")
+    }
+  }
+
+  @Throws(IOException::class)
+  private fun createUploadRequest(url: String, fileUriString: String, options: UploaderOptions, decorator: RequestBodyDecorator): Request {
+    val fileUri = Uri.parse(slashifyFilePath(fileUriString))
+    fileUri.checkIfFileExists()
+
+    val requestBuilder = Request.Builder().url(url)
+    options.headers?.let {
+      it.forEach { (key, value) -> requestBuilder.addHeader(key, value) }
+    }
+
+    val body = createRequestBody(options, decorator, fileUri.toFile())
+    return options.httpMethod.let { requestBuilder.method(it.value, body).build() }
+  }
+
+  @SuppressLint("NewApi")
+  private fun createRequestBody(options: UploaderOptions, decorator: RequestBodyDecorator, file: File): RequestBody {
+    return when (options.uploadType) {
+      UploadType.BINARY_CONTENT -> {
+        val mimeType: String? = if (options.mimeType?.isNotEmpty() == true) {
+          options.mimeType
+        } else {
+          getContentType(reactContext, file) ?: "application/octet-stream"
+        }
+        val contentType = mimeType?.toMediaTypeOrNull()
+        decorator.decorate(file.asRequestBody(contentType))
+      }
+
+      UploadType.MULTIPART -> {
+        val bodyBuilder = MultipartBody.Builder().setType(MultipartBody.FORM)
+        options.parameters?.let {
+          (it as Map<String, Any>)
+            .forEach { (key, value) -> bodyBuilder.addFormDataPart(key, value.toString()) }
         }
+        val mimeType: String = options.mimeType ?: URLConnection.guessContentTypeFromName(file.name)
+
+        val fieldName = options.fieldName ?: file.name
+        bodyBuilder.addFormDataPart(fieldName, file.name, decorator.decorate(file.asRequestBody(mimeType.toMediaTypeOrNull())))
+        bodyBuilder.build()
+      }
+    }
+  }
+
+  fun getContentType(context: ReactApplicationContext, file: File): String? {
+    val contentResolver: ContentResolver = context.contentResolver
+    val fileUri = Uri.fromFile(file)
+
+    // Try to get the MIME type from the ContentResolver
+    val mimeType = contentResolver.getType(fileUri)
+
+    // If the ContentResolver couldn't determine the MIME type, try to infer it from the file extension
+    if (mimeType == null) {
+      val fileExtension = MimeTypeMap.getFileExtensionFromUrl(fileUri.toString())
+      if (fileExtension != null) {
+        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileExtension.toLowerCase())
+      }
+    }
+
+    return mimeType
+  }
+
+  @Throws(IOException::class)
+  private fun Uri.checkIfFileExists() {
+    val file = this.toFile()
+    if (!file.exists()) {
+      throw IOException("Directory for '${file.path}' doesn't exist.")
+    }
+  }
+
+  // extension functions of Uri class
+  private fun Uri.toFile() = if (this.path != null) {
+    File(this.path!!)
+  } else {
+    throw IOException("Invalid Uri: $this")
+  }
+
+  private fun translateHeaders(headers: Headers): ReadableMap {
+    val responseHeaders = Arguments.createMap()
+    for (i in 0 until headers.size) {
+      val headerName = headers.name(i)
+      // multiple values for the same header
+      if (responseHeaders.hasKey(headerName)) {
+        val existingValue = responseHeaders.getString(headerName)
+        responseHeaders.putString(headerName, "$existingValue, ${headers.value(i)}")
+      } else {
+        responseHeaders.putString(headerName, headers.value(i))
       }
-      return options
     }
+    return responseHeaders
   }
 }

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/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/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/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

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["Video","Audio","Image","getDetails","uuidv4","generateFilePath","getRealPath","getVideoMetaData","getFileSize","backgroundUpload","createVideoThumbnail","download","clearCache"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA,OAAOA,KAAK,MAAM,SAAS;AAE3B,OAAOC,KAAK,MAAM,SAAS;AAC3B,OAAOC,KAAK,MAAM,SAAS;AAC3B,SACEC,UAAU,EACVC,MAAM,EACNC,gBAAgB,EAChBC,WAAW,EACXC,gBAAgB,EAChBC,WAAW,EACXC,gBAAgB,EAChBC,oBAAoB,EACpBC,QAAQ,EACRC,UAAU,QACL,SAAS;AAEhB,SACEZ,KAAK,EACLC,KAAK,EACLC,KAAK,EACLO,gBAAgB,EAChBE,QAAQ;AACR;AACAR,UAAU,EACVC,MAAM,EACNC,gBAAgB,EAChBC,WAAW,EACXC,gBAAgB,EAChBG,oBAAoB,EACpBE,UAAU,EACVJ,WAAW;AAGb,eAAe;EACbR,KAAK;EACLC,KAAK;EACLC,KAAK;EACLC,UAAU;EACVC,MAAM;EACNC,gBAAgB;EAChBC,WAAW;EACXC,gBAAgB;EAChBC,WAAW;EACXC,gBAAgB;EAChBC,oBAAoB;EACpBE,UAAU;EACVD;AACF,CAAC"}
+{"version":3,"names":["Video","Audio","Image","getDetails","uuidv4","generateFilePath","getRealPath","getVideoMetaData","getFileSize","backgroundUpload","createVideoThumbnail","download","clearCache","UploadType","UploaderHttpMethod"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA,OAAOA,KAAK,MAAM,SAAS;AAE3B,OAAOC,KAAK,MAAM,SAAS;AAC3B,OAAOC,KAAK,MAAM,SAAS;AAC3B,SACEC,UAAU,EACVC,MAAM,EACNC,gBAAgB,EAChBC,WAAW,EACXC,gBAAgB,EAChBC,WAAW,EACXC,gBAAgB,EAChBC,oBAAoB,EACpBC,QAAQ,EACRC,UAAU,EACVC,UAAU,EACVC,kBAAkB,QACb,SAAS;AAEhB,SACEd,KAAK,EACLC,KAAK,EACLC,KAAK,EACLO,gBAAgB,EAChBE,QAAQ;AACR;AACAR,UAAU,EACVC,MAAM,EACNC,gBAAgB,EAChBC,WAAW,EACXC,gBAAgB,EAChBG,oBAAoB,EACpBE,UAAU,EACVJ,WAAW,EACXK,UAAU,EACVC,kBAAkB;AAGpB,eAAe;EACbd,KAAK;EACLC,KAAK;EACLC,KAAK;EACLC,UAAU;EACVC,MAAM;EACNC,gBAAgB;EAChBC,WAAW;EACXC,gBAAgB;EAChBC,WAAW;EACXC,gBAAgB;EAChBC,oBAAoB;EACpBE,UAAU;EACVD,QAAQ;EACRE,UAAU;EACVC;AACF,CAAC"}

package/lib/module/utils/Uploader.js

@@ -2,6 +2,17 @@ import { NativeEventEmitter, Platform } from 'react-native';
 import { Compressor } from '../Main';
 const CompressEventEmitter = new NativeEventEmitter(Compressor);
 import { uuidv4 } from '.';
+export let UploadType = /*#__PURE__*/function (UploadType) {
+  UploadType[UploadType["BINARY_CONTENT"] = 0] = "BINARY_CONTENT";
+  UploadType[UploadType["MULTIPART"] = 1] = "MULTIPART";
+  return UploadType;
+}({});
+export let UploaderHttpMethod = /*#__PURE__*/function (UploaderHttpMethod) {
+  UploaderHttpMethod["POST"] = "POST";
+  UploaderHttpMethod["PUT"] = "PUT";
+  UploaderHttpMethod["PATCH"] = "PATCH";
+  return UploaderHttpMethod;
+}({});
 export const backgroundUpload = async (url, fileUrl, options, onProgress) => {
   const uuid = uuidv4();
   let subscription;
@@ -20,6 +31,8 @@ export const backgroundUpload = async (url, fileUrl, options, onProgress) => {
       uuid,
       method: options.httpMethod,
       headers: options.headers,
+      uploadType: options.uploadType,
+      ...options,
       url
     });
     return result;

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

@@ -1 +1 @@
-{"version":3,"names":["NativeEventEmitter","Platform","Compressor","CompressEventEmitter","uuidv4","backgroundUpload","url","fileUrl","options","onProgress","uuid","subscription","addListener","event","data","written","total","OS","includes","replace","result","upload","method","httpMethod","headers","remove"],"sourceRoot":"../../../src","sources":["utils/Uploader.tsx"],"mappings":"AAAA,SAASA,kBAAkB,EAAEC,QAAQ,QAAQ,cAAc;AAE3D,SAASC,UAAU,QAAQ,SAAS;AACpC,MAAMC,oBAAoB,GAAG,IAAIH,kBAAkB,CAACE,UAAU,CAAC;AAC/D,SAASE,MAAM,QAAQ,GAAG;AAsC1B,OAAO,MAAMC,gBAAgB,GAAG,MAAAA,CAC9BC,GAAW,EACXC,OAAe,EACfC,OAAgC,EAChCC,UAAqD,KACpC;EACjB,MAAMC,IAAI,GAAGN,MAAM,CAAC,CAAC;EACrB,IAAIO,YAAqC;EACzC,IAAI;IACF,IAAIF,UAAU,EAAE;MACdE,YAAY,GAAGR,oBAAoB,CAACS,WAAW,CAC7C,gBAAgB,EACfC,KAAU,IAAK;QACd,IAAIA,KAAK,CAACH,IAAI,KAAKA,IAAI,EAAE;UACvBD,UAAU,CAACI,KAAK,CAACC,IAAI,CAACC,OAAO,EAAEF,KAAK,CAACC,IAAI,CAACE,KAAK,CAAC;QAClD;MACF,CACF,CAAC;IACH;IACA,IAAIf,QAAQ,CAACgB,EAAE,KAAK,SAAS,IAAIV,OAAO,CAACW,QAAQ,CAAC,SAAS,CAAC,EAAE;MAC5DX,OAAO,GAAGA,OAAO,CAACY,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;IAC1C;IACA,MAAMC,MAAM,GAAG,MAAMlB,UAAU,CAACmB,MAAM,CAACd,OAAO,EAAE;MAC9CG,IAAI;MACJY,MAAM,EAAEd,OAAO,CAACe,UAAU;MAC1BC,OAAO,EAAEhB,OAAO,CAACgB,OAAO;MACxBlB;IACF,CAAC,CAAC;IACF,OAAOc,MAAM;EACf,CAAC,SAAS;IACR;IACA,IAAIT,YAAY,EAAE;MAChBA,YAAY,CAACc,MAAM,CAAC,CAAC;IACvB;EACF;AACF,CAAC"}
+{"version":3,"names":["NativeEventEmitter","Platform","Compressor","CompressEventEmitter","uuidv4","UploadType","UploaderHttpMethod","backgroundUpload","url","fileUrl","options","onProgress","uuid","subscription","addListener","event","data","written","total","OS","includes","replace","result","upload","method","httpMethod","headers","uploadType","remove"],"sourceRoot":"../../../src","sources":["utils/Uploader.tsx"],"mappings":"AAAA,SAASA,kBAAkB,EAAEC,QAAQ,QAAQ,cAAc;AAE3D,SAASC,UAAU,QAAQ,SAAS;AACpC,MAAMC,oBAAoB,GAAG,IAAIH,kBAAkB,CAACE,UAAU,CAAC;AAC/D,SAASE,MAAM,QAAQ,GAAG;AAC1B,WAAYC,UAAU,0BAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAA,OAAVA,UAAU;AAAA;AAKtB,WAAYC,kBAAkB,0BAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAA,OAAlBA,kBAAkB;AAAA;AA8B9B,OAAO,MAAMC,gBAAgB,GAAG,MAAAA,CAC9BC,GAAW,EACXC,OAAe,EACfC,OAAwB,EACxBC,UAAqD,KACpC;EACjB,MAAMC,IAAI,GAAGR,MAAM,CAAC,CAAC;EACrB,IAAIS,YAAqC;EACzC,IAAI;IACF,IAAIF,UAAU,EAAE;MACdE,YAAY,GAAGV,oBAAoB,CAACW,WAAW,CAC7C,gBAAgB,EACfC,KAAU,IAAK;QACd,IAAIA,KAAK,CAACH,IAAI,KAAKA,IAAI,EAAE;UACvBD,UAAU,CAACI,KAAK,CAACC,IAAI,CAACC,OAAO,EAAEF,KAAK,CAACC,IAAI,CAACE,KAAK,CAAC;QAClD;MACF,CACF,CAAC;IACH;IACA,IAAIjB,QAAQ,CAACkB,EAAE,KAAK,SAAS,IAAIV,OAAO,CAACW,QAAQ,CAAC,SAAS,CAAC,EAAE;MAC5DX,OAAO,GAAGA,OAAO,CAACY,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;IAC1C;IACA,MAAMC,MAAM,GAAG,MAAMpB,UAAU,CAACqB,MAAM,CAACd,OAAO,EAAE;MAC9CG,IAAI;MACJY,MAAM,EAAEd,OAAO,CAACe,UAAU;MAC1BC,OAAO,EAAEhB,OAAO,CAACgB,OAAO;MACxBC,UAAU,EAAEjB,OAAO,CAACiB,UAAU;MAC9B,GAAGjB,OAAO;MACVF;IACF,CAAC,CAAC;IACF,OAAOc,MAAM;EACf,CAAC,SAAS;IACR;IACA,IAAIT,YAAY,EAAE;MAChBA,YAAY,CAACe,MAAM,CAAC,CAAC;IACvB;EACF;AACF,CAAC"}

package/lib/typescript/index.d.ts

@@ -2,8 +2,8 @@ import Video from './Video';
 import type { VideoCompressorType } from './Video';
 import Audio from './Audio';
 import Image from './Image';
-import { getDetails, uuidv4, generateFilePath, getRealPath, getVideoMetaData, getFileSize, backgroundUpload, createVideoThumbnail, download, clearCache } from './utils';
-export { Video, Audio, Image, backgroundUpload, download, getDetails, uuidv4, generateFilePath, getRealPath, getVideoMetaData, createVideoThumbnail, clearCache, getFileSize, };
+import { getDetails, uuidv4, generateFilePath, getRealPath, getVideoMetaData, getFileSize, backgroundUpload, createVideoThumbnail, download, clearCache, UploadType, UploaderHttpMethod } from './utils';
+export { Video, Audio, Image, backgroundUpload, download, getDetails, uuidv4, generateFilePath, getRealPath, getVideoMetaData, createVideoThumbnail, clearCache, getFileSize, UploadType, UploaderHttpMethod, };
 export type { VideoCompressorType };
 declare const _default: {
     Video: VideoCompressorType;
@@ -17,7 +17,7 @@ declare const _default: {
     getRealPath: (path: string, type: "video" | "image") => Promise<string>;
     getVideoMetaData: (filePath: string) => Promise<string>;
     getFileSize: (filePath: string) => Promise<string>;
-    backgroundUpload: (url: string, fileUrl: string, options: import("./utils").FileSystemUploadOptions, onProgress?: ((writtem: number, total: number) => void) | undefined) => Promise<any>;
+    backgroundUpload: (url: string, fileUrl: string, options: import("./utils").UploaderOptions, onProgress?: ((writtem: number, total: number) => void) | undefined) => Promise<any>;
     createVideoThumbnail: (fileUrl: string, options?: {
         headers?: {
             [key: string]: string;
@@ -31,6 +31,8 @@ declare const _default: {
     }>;
     clearCache: (cacheDir?: string | undefined) => Promise<string>;
     download: (fileUrl: string, downloadProgress?: ((progress: number) => void) | undefined, progressDivider?: number | undefined) => Promise<any>;
+    UploadType: typeof UploadType;
+    UploaderHttpMethod: typeof UploaderHttpMethod;
 };
 export default _default;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,EACL,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,QAAQ,EACR,UAAU,EACX,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,gBAAgB,EAChB,QAAQ,EAER,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,UAAU,EACV,WAAW,GACZ,CAAC;AACF,YAAY,EAAE,mBAAmB,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACpC,wBAcE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,EACL,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,QAAQ,EACR,UAAU,EACV,UAAU,EACV,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,gBAAgB,EAChB,QAAQ,EAER,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,UAAU,EACV,WAAW,EACX,UAAU,EACV,kBAAkB,GACnB,CAAC;AACF,YAAY,EAAE,mBAAmB,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACpC,wBAgBE"}

package/lib/typescript/utils/Uploader.d.ts

@@ -1,28 +1,29 @@
-export declare enum FileSystemUploadType {
+export declare enum UploadType {
     BINARY_CONTENT = 0,
     MULTIPART = 1
 }
-export declare enum FileSystemSessionType {
-    BACKGROUND = 0,
-    FOREGROUND = 1
+export declare enum UploaderHttpMethod {
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH"
 }
 export declare type HTTPResponse = {
     status: number;
     headers: Record<string, string>;
     body: string;
 };
-export declare type FileSystemAcceptedUploadHttpMethod = 'POST' | 'PUT' | 'PATCH';
-export declare type FileSystemUploadOptions = ({
-    uploadType?: FileSystemUploadType.BINARY_CONTENT;
+export declare type HttpMethod = 'POST' | 'PUT' | 'PATCH';
+export declare type UploaderOptions = ({
+    uploadType?: UploadType.BINARY_CONTENT;
+    mimeType?: string;
 } | {
-    uploadType: FileSystemUploadType.MULTIPART;
+    uploadType: UploadType.MULTIPART;
     fieldName?: string;
     mimeType?: string;
     parameters?: Record<string, string>;
 }) & {
     headers?: Record<string, string>;
-    httpMethod?: FileSystemAcceptedUploadHttpMethod;
-    sessionType?: FileSystemSessionType;
+    httpMethod?: UploaderHttpMethod | HttpMethod;
 };
-export declare const backgroundUpload: (url: string, fileUrl: string, options: FileSystemUploadOptions, onProgress?: ((writtem: number, total: number) => void) | undefined) => Promise<any>;
+export declare const backgroundUpload: (url: string, fileUrl: string, options: UploaderOptions, onProgress?: ((writtem: number, total: number) => void) | undefined) => Promise<any>;
 //# sourceMappingURL=Uploader.d.ts.map

package/lib/typescript/utils/Uploader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Uploader.d.ts","sourceRoot":"","sources":["../../../src/utils/Uploader.tsx"],"names":[],"mappings":"AAKA,MAAM,CAAC,OAAO,MAAM,oBAAoB;IACtC,cAAc,IAAI;IAClB,SAAS,IAAI;CACd;AAED,MAAM,CAAC,OAAO,MAAM,qBAAqB;IACvC,UAAU,IAAI;IACd,UAAU,IAAI;CACf;AAED,MAAM,CAAC,OAAO,MAAM,YAAY,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,CAAC,OAAO,MAAM,kCAAkC,GAClD,MAAM,GACN,KAAK,GACL,OAAO,CAAC;AAEZ,MAAM,CAAC,OAAO,MAAM,uBAAuB,GAAG,CAC1C;IACE,UAAU,CAAC,EAAE,oBAAoB,CAAC,cAAc,CAAC;CAClD,GACD;IACE,UAAU,EAAE,oBAAoB,CAAC,SAAS,CAAC;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC,CACJ,GAAG;IACF,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,kCAAkC,CAAC;IAChD,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,gBAAgB,QACtB,MAAM,WACF,MAAM,WACN,uBAAuB,0BACT,MAAM,SAAS,MAAM,KAAK,IAAI,kBACpD,QAAQ,GAAG,CA8Bb,CAAC"}
+{"version":3,"file":"Uploader.d.ts","sourceRoot":"","sources":["../../../src/utils/Uploader.tsx"],"names":[],"mappings":"AAKA,oBAAY,UAAU;IACpB,cAAc,IAAI;IAClB,SAAS,IAAI;CACd;AAED,oBAAY,kBAAkB;IAC5B,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,KAAK,UAAU;CAChB;AAED,MAAM,CAAC,OAAO,MAAM,YAAY,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,CAAC,OAAO,MAAM,UAAU,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;AAE1D,MAAM,CAAC,OAAO,MAAM,eAAe,GAAG,CAClC;IACE,UAAU,CAAC,EAAE,UAAU,CAAC,cAAc,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACD;IACE,UAAU,EAAE,UAAU,CAAC,SAAS,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC,CACJ,GAAG;IACF,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,kBAAkB,GAAG,UAAU,CAAC;CAC9C,CAAC;AAEF,eAAO,MAAM,gBAAgB,QACtB,MAAM,WACF,MAAM,WACN,eAAe,0BACD,MAAM,SAAS,MAAM,KAAK,IAAI,kBACpD,QAAQ,GAAG,CAgCb,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-compressor",
-  "version": "1.8.9",
+  "version": "1.8.11",
   "description": "This library compress image, video and audio",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/index.tsx

@@ -13,6 +13,8 @@ import {
   createVideoThumbnail,
   download,
   clearCache,
+  UploadType,
+  UploaderHttpMethod,
 } from './utils';
 
 export {
@@ -30,6 +32,8 @@ export {
   createVideoThumbnail,
   clearCache,
   getFileSize,
+  UploadType,
+  UploaderHttpMethod,
 };
 export type { VideoCompressorType };
 export default {
@@ -46,4 +50,6 @@ export default {
   createVideoThumbnail,
   clearCache,
   download,
+  UploadType,
+  UploaderHttpMethod,
 };

package/src/utils/Uploader.tsx

@@ -3,14 +3,15 @@ import type { NativeEventSubscription } from 'react-native';
 import { Compressor } from '../Main';
 const CompressEventEmitter = new NativeEventEmitter(Compressor);
 import { uuidv4 } from '.';
-export declare enum FileSystemUploadType {
+export enum UploadType {
   BINARY_CONTENT = 0,
   MULTIPART = 1,
 }
 
-export declare enum FileSystemSessionType {
-  BACKGROUND = 0,
-  FOREGROUND = 1,
+export enum UploaderHttpMethod {
+  POST = 'POST',
+  PUT = 'PUT',
+  PATCH = 'PATCH',
 }
 
 export declare type HTTPResponse = {
@@ -19,31 +20,28 @@ export declare type HTTPResponse = {
   body: string;
 };
 
-export declare type FileSystemAcceptedUploadHttpMethod =
-  | 'POST'
-  | 'PUT'
-  | 'PATCH';
+export declare type HttpMethod = 'POST' | 'PUT' | 'PATCH';
 
-export declare type FileSystemUploadOptions = (
+export declare type UploaderOptions = (
   | {
-      uploadType?: FileSystemUploadType.BINARY_CONTENT;
+      uploadType?: UploadType.BINARY_CONTENT;
+      mimeType?: string;
     }
   | {
-      uploadType: FileSystemUploadType.MULTIPART;
+      uploadType: UploadType.MULTIPART;
       fieldName?: string;
       mimeType?: string;
       parameters?: Record<string, string>;
     }
 ) & {
   headers?: Record<string, string>;
-  httpMethod?: FileSystemAcceptedUploadHttpMethod;
-  sessionType?: FileSystemSessionType;
+  httpMethod?: UploaderHttpMethod | HttpMethod;
 };
 
 export const backgroundUpload = async (
   url: string,
   fileUrl: string,
-  options: FileSystemUploadOptions,
+  options: UploaderOptions,
   onProgress?: (writtem: number, total: number) => void
 ): Promise<any> => {
   const uuid = uuidv4();
@@ -66,6 +64,8 @@ export const backgroundUpload = async (
       uuid,
       method: options.httpMethod,
       headers: options.headers,
+      uploadType: options.uploadType,
+      ...options,
       url,
     });
     return result;