react-native-my-uploader-android 1.0.27 → 1.0.29

package/android/src/main/java/com/myuploaderandroid/DownloadFileModule.kt

@@ -12,54 +12,70 @@ import android.util.Log
 import android.webkit.CookieManager
 import android.webkit.URLUtil
 import com.facebook.react.bridge.*
-import com.myuploaderandroid.BuildConfig
+import java.io.File
 import java.net.HttpURLConnection
 import java.net.URL
+import java.util.concurrent.ConcurrentHashMap
 
 class DownloadFileModule(private val reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
     private val TAG = "DownloadFileModule"
-    private val downloadPromises = mutableMapOf<Long, Promise>()
+    private val downloadPromises = ConcurrentHashMap<Long, Promise>()
 
-    override fun getName(): String = "DownloadFile"
-
-    init {
-        val receiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                val downloadId = intent.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, -1)
-                if (downloadPromises.containsKey(downloadId)) {
-                    val promise = downloadPromises[downloadId]
+    private val receiver: BroadcastReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            val downloadId = intent.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, -1)
+            if (downloadId != -1L) {
+                downloadPromises.remove(downloadId)?.let { promise ->
                     checkDownloadStatus(downloadId, promise)
-                    downloadPromises.remove(downloadId)
                 }
             }
         }
+    }
+
+    override fun getName(): String = "DownloadFile"
+
+    init {
         val intentFilter = IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE)
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-             reactContext.registerReceiver(receiver, intentFilter, Context.RECEIVER_NOT_EXPORTED)
+            reactContext.registerReceiver(receiver, intentFilter, Context.RECEIVER_NOT_EXPORTED)
         } else {
-             reactContext.registerReceiver(receiver, intentFilter)
+            reactContext.registerReceiver(receiver, intentFilter)
         }
     }
 
+    override fun onCatalystInstanceDestroy() {
+        try {
+            reactContext.unregisterReceiver(receiver)
+        } catch (e: Exception) {
+            Log.w(TAG, "Receiver unregister warning: ${e.message}")
+        }
+        super.onCatalystInstanceDestroy()
+    }
+
     @ReactMethod
     fun downloadFile(fileUrl: String, options: ReadableMap, promise: Promise) {
         val isDebug = if (options.hasKey("debug")) options.getBoolean("debug") else false
-        val shouldLog = BuildConfig.DEBUG && isDebug
         val maxSizeMB = if (options.hasKey("maxSize")) options.getDouble("maxSize") else 0.0
+        
+        // Allowed File Types (Mime Types)
+        val allowedTypes = if (options.hasKey("fileTypes")) {
+            options.getArray("fileTypes")?.toArrayList()?.mapNotNull { it.toString() } ?: emptyList()
+        } else emptyList()
 
-        if (shouldLog) Log.d(TAG, "İndirme isteği alındı. URL: $fileUrl")
+        if (isDebug) Log.d(TAG, "İndirme başlatılıyor: $fileUrl")
 
         Thread {
+            var connection: HttpURLConnection? = null
             try {
                 val url = URL(fileUrl)
-                val connection = url.openConnection() as HttpURLConnection
+                connection = url.openConnection() as HttpURLConnection
                 val cookie = CookieManager.getInstance().getCookie(fileUrl)
                 if (cookie != null) connection.setRequestProperty("Cookie", cookie)
-                connection.requestMethod = "HEAD"
+                connection.requestMethod = "HEAD" // Sadece başlıkları çek
                 connection.connect()
-                
+
                 val responseCode = connection.responseCode
                 if (responseCode !in 200..299) {
                     promise.reject("E_HTTP_ERROR", "Sunucu hatası: $responseCode")
@@ -68,22 +84,49 @@ class DownloadFileModule(private val reactContext: ReactApplicationContext) :
 
                 val fileSize = connection.contentLengthLong
                 val contentType = connection.contentType
-                val contentDisposition = connection.getHeaderField("Content-Disposition")
                 val cleanContentType = contentType?.split(";")?.get(0)?.trim() ?: "*/*"
+                
+                // 1. Content-Type Kontrolü
+                if (allowedTypes.isNotEmpty() && !allowedTypes.contains("*/*")) {
+                    var isAllowed = false
+                    for (type in allowedTypes) {
+                        if (type == "*/*" || cleanContentType.equals(type, ignoreCase = true) || cleanContentType.startsWith(type.replace("*", ""))) {
+                            isAllowed = true
+                            break
+                        }
+                    }
+                    if (!isAllowed) {
+                        promise.reject("E_INVALID_FILE_TYPE", "Dosya türü ($cleanContentType) izin verilenler listesinde yok.")
+                        return@Thread
+                    }
+                }
+
+                // 2. Boyut Kontrolü
+                if (maxSizeMB > 0 && fileSize > 0 && fileSize > maxSizeMB * 1024 * 1024) {
+                    promise.reject("E_FILE_TOO_LARGE", "Dosya boyutu (${(fileSize / 1024.0 / 1024.0).toInt()}MB) limitin (${maxSizeMB}MB) üzerinde.")
+                    return@Thread
+                }
+
+                val contentDisposition = connection.getHeaderField("Content-Disposition")
                 val fileName = URLUtil.guessFileName(fileUrl, contentDisposition, cleanContentType)
 
-                if (shouldLog) Log.d(TAG, "Dosya: $fileName, Boyut: $fileSize bytes, Tip: $cleanContentType")
+                // Dosya Adı Çakışma Önleme
+                val downloadsDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
+                val baseName = fileName.substringBeforeLast(".")
+                val ext = fileName.substringAfterLast(".", "")
+                var counter = 1
+                var finalFileName = fileName
                 
-                if (maxSizeMB > 0 && fileSize > maxSizeMB * 1024 * 1024) {
-                    promise.reject("E_FILE_TOO_LARGE", "Dosya boyutu (${(fileSize / 1024.0 / 1024.0).toInt()}MB) belirtilen limitten (${maxSizeMB}MB) büyük.")
-                    return@Thread
+                while (File(downloadsDir, finalFileName).exists()) {
+                    finalFileName = if (ext.isNotEmpty()) "$baseName($counter).$ext" else "$baseName($counter)"
+                    counter++
                 }
 
                 val request = DownloadManager.Request(Uri.parse(fileUrl))
-                    .setTitle(fileName)
-                    .setDescription("İndiriliyor...")
+                    .setTitle(finalFileName)
+                    .setDescription("Dosya indiriliyor...")
                     .setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
-                    .setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, fileName)
+                    .setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, finalFileName)
                     .setAllowedOverMetered(true)
 
                 if (cookie != null) request.addRequestHeader("Cookie", cookie)
@@ -91,13 +134,13 @@ class DownloadFileModule(private val reactContext: ReactApplicationContext) :
 
                 val downloadManager = reactContext.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
                 val downloadId = downloadManager.enqueue(request)
-                
-                if (BuildConfig.DEBUG) Log.i(TAG, "İndirme sıraya eklendi. ID: #$downloadId")
+
                 downloadPromises[downloadId] = promise
 
             } catch (e: Exception) {
-                if (BuildConfig.DEBUG) Log.e(TAG, "İndirme başlatılırken hata!", e)
                 promise.reject("E_DOWNLOAD_SETUP_FAILED", e.message)
+            } finally {
+                connection?.disconnect()
             }
         }.start()
     }
@@ -107,38 +150,28 @@ class DownloadFileModule(private val reactContext: ReactApplicationContext) :
         val query = DownloadManager.Query().setFilterById(id)
         val cursor = downloadManager.query(query)
 
-        if (cursor.moveToFirst()) {
-            val statusIndex = cursor.getColumnIndex(DownloadManager.COLUMN_STATUS)
-            val status = cursor.getInt(statusIndex)
+        if (cursor == null) {
+            promise?.reject("E_DB_CURSOR_NULL", "Download cursor null")
+            return
+        }
 
-            if (status == DownloadManager.STATUS_SUCCESSFUL) {
-                val uriIndex = cursor.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI)
-                val localUri = cursor.getString(uriIndex)
-                promise?.resolve(localUri)
+        cursor.use {
+            if (it.moveToFirst()) {
+                val statusIndex = it.getColumnIndex(DownloadManager.COLUMN_STATUS)
+                val status = if (statusIndex >= 0) it.getInt(statusIndex) else DownloadManager.STATUS_FAILED
+
+                if (status == DownloadManager.STATUS_SUCCESSFUL) {
+                    val uriIndex = it.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI)
+                    val localUri = if (uriIndex >= 0) it.getString(uriIndex) else null
+                    promise?.resolve(localUri)
+                } else {
+                    val reasonIndex = it.getColumnIndex(DownloadManager.COLUMN_REASON)
+                    val reason = if (reasonIndex >= 0) it.getInt(reasonIndex) else -1
+                    promise?.reject("E_DOWNLOAD_FAILED", "İndirme başarısız kod: $reason")
+                }
             } else {
-                val reasonIndex = cursor.getColumnIndex(DownloadManager.COLUMN_REASON)
-                val reason = cursor.getInt(reasonIndex)
-                val reasonText = getDownloadErrorReason(reason)
-                promise?.reject("E_DOWNLOAD_FAILED", "İndirme başarısız. Sebep: $reasonText (Kod: $reason)")
+                promise?.reject("E_DOWNLOAD_NOT_FOUND", "İndirme kaydı bulunamadı.")
             }
-        } else {
-            promise?.reject("E_DOWNLOAD_NOT_FOUND", "İndirme işlemi bulunamadı.")
-        }
-        cursor.close()
-    }
-
-    private fun getDownloadErrorReason(reasonCode: Int): String {
-        return when (reasonCode) {
-            DownloadManager.ERROR_CANNOT_RESUME -> "İndirme devam ettirilemiyor."
-            DownloadManager.ERROR_DEVICE_NOT_FOUND -> "Harici depolama bulunamadı."
-            DownloadManager.ERROR_FILE_ALREADY_EXISTS -> "Aynı isimde bir dosya zaten var."
-            DownloadManager.ERROR_FILE_ERROR -> "Dosya sistemi hatası."
-            DownloadManager.ERROR_HTTP_DATA_ERROR -> "Sunucu ile veri alışverişinde hata."
-            DownloadManager.ERROR_INSUFFICIENT_SPACE -> "Cihazda yeterli alan yok."
-            DownloadManager.ERROR_TOO_MANY_REDIRECTS -> "Çok fazla yönlendirme yapıldı."
-            DownloadManager.ERROR_UNHANDLED_HTTP_CODE -> "Sunucudan beklenmeyen HTTP kodu alındı."
-            DownloadManager.ERROR_UNKNOWN -> "Bilinmeyen bir hata oluştu."
-            else -> "Bilinmeyen hata."
         }
     }
 }

package/android/src/main/java/com/myuploaderandroid/MyUploaderModule.kt

@@ -14,7 +14,7 @@ class MyUploaderModule(private val reactContext: ReactApplicationContext) :
 
     private var pickerPromise: Promise? = null
     private var maxSize: Double = 0.0
-    private var maxFiles: Int = 0
+    private var maxFiles: Int = 1
     private var excludedUris: List<String> = emptyList()
 
     init {
@@ -25,149 +25,133 @@ class MyUploaderModule(private val reactContext: ReactApplicationContext) :
 
     companion object {
         private const val REQUEST_CODE = 9900
-        private const val E_ACTIVITY_DOES_NOT_EXIST = "E_ACTIVITY_DOES_NOT_EXIST"
-        private const val E_PICKER_CANCELLED = "E_PICKER_CANCELLED"
-        private const val E_FAILED_TO_OPEN_DOCUMENT = "E_FAILED_TO_OPEN_DOCUMENT"
-        private const val E_FILE_TOO_LARGE = "E_FILE_TOO_LARGE"
-        private const val E_MAX_FILES_EXCEEDED = "E_MAX_FILES_EXCEEDED"
-        private const val E_INVALID_OPTIONS = "E_INVALID_OPTIONS"
     }
 
     @ReactMethod
     fun openDocument(options: ReadableMap, promise: Promise) {
         if (pickerPromise != null) {
-            promise.reject(E_FAILED_TO_OPEN_DOCUMENT, "Başka bir dosya seçme işlemi zaten devam ediyor.")
+            promise.reject("E_BUSY", "Zaten açık bir işlem var.")
             return
         }
 
         this.pickerPromise = promise
         
-        val multipleFiles = options.takeIf { it.hasKey("multipleFiles") }?.getBoolean("multipleFiles") ?: false
-        val jsMaxFiles = options.takeIf { it.hasKey("maxFiles") }?.getInt("maxFiles") ?: 0
-
-        // KURAL KONTROLÜ (NATIVE): JS tarafındaki kontrolü burada da yaparak güvenliği artır.
-        if (!multipleFiles && jsMaxFiles > 1) {
-            promise.reject(E_INVALID_OPTIONS, "`maxFiles` değeri, `multipleFiles` false iken 1'den büyük olamaz.")
-            return
-        }
-
-        // KURAL UYGULAMA (NATIVE): `maxFiles` için nihai değeri hesapla.
-        val effectiveMaxFiles = when {
-            multipleFiles && jsMaxFiles == 0 -> 3 // Varsayılan: 3
-            !multipleFiles -> 1 // Tekli seçimde her zaman 1
-            else -> jsMaxFiles // Belirtilen değeri kullan
+        // JS'den gelen opsiyonları al
+        val multipleFiles = if(options.hasKey("multipleFiles")) options.getBoolean("multipleFiles") else false
+        val jsMaxFiles = if(options.hasKey("maxFiles")) options.getInt("maxFiles") else 0
+        this.maxSize = if(options.hasKey("maxSize")) options.getDouble("maxSize") else 0.0
+        this.excludedUris = if(options.hasKey("excludedUris")) 
+            options.getArray("excludedUris")?.toArrayList()?.mapNotNull { it.toString() } ?: emptyList() 
+            else emptyList()
+
+        // maxFiles mantığı
+        this.maxFiles = when {
+            multipleFiles && jsMaxFiles == 0 -> 99 // Limit yoksa varsayılan
+            !multipleFiles -> 1
+            else -> jsMaxFiles
         }
 
-        // Değerleri sınıf değişkenlerine ata
-        this.maxFiles = effectiveMaxFiles
-        this.maxSize = options.takeIf { it.hasKey("maxSize") }?.getDouble("maxSize") ?: 0.0
-        this.excludedUris = options.takeIf { it.hasKey("excludedUris") }
-            ?.getArray("excludedUris")?.toArrayList()?.mapNotNull { it.toString() } ?: emptyList()
-
-        val currentActivity = reactContext.currentActivity
+        val currentActivity = currentActivity
         if (currentActivity == null) {
-            pickerPromise?.reject(E_ACTIVITY_DOES_NOT_EXIST, "Activity mevcut değil.")
+            promise.reject("E_NO_ACTIVITY", "Activity bulunamadı.")
             pickerPromise = null
             return
         }
 
-        val fileTypes = options.takeIf { it.hasKey("fileTypes") }
-            ?.getArray("fileTypes")?.toArrayList()?.mapNotNull { it.toString() } ?: listOf("*/*")
-        val mimeTypes = if (fileTypes.isEmpty()) arrayOf("*/*") else fileTypes.toTypedArray()
+        val fileTypes = if (options.hasKey("fileTypes")) 
+            options.getArray("fileTypes")?.toArrayList()?.mapNotNull { it.toString() } ?: listOf("*/*")
+            else listOf("*/*")
+            
+        val mimeTypes = fileTypes.toTypedArray()
 
         try {
-            // ANAHTAR: ACTION_GET_CONTENT, güvenilir çoklu seçimi etkinleştirir.
             val intent = Intent(Intent.ACTION_GET_CONTENT).apply {
-                type = "*/*"
+                type = "*/*" // Filter by MIME types in extra
                 addCategory(Intent.CATEGORY_OPENABLE)
                 putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes)
-
-                if (multipleFiles) {
-                    putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
-                }
+                if (multipleFiles) putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
             }
-            currentActivity.startActivityForResult(Intent.createChooser(intent, "Dosya Seçin"), REQUEST_CODE)
+            currentActivity.startActivityForResult(Intent.createChooser(intent, "Dosya Seç"), REQUEST_CODE)
         } catch (e: Exception) {
-            pickerPromise?.reject(E_FAILED_TO_OPEN_DOCUMENT, e)
+            pickerPromise?.reject("E_OPEN_FAILED", e)
             pickerPromise = null
         }
     }
 
     override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
-        if (requestCode != REQUEST_CODE || pickerPromise == null) { return }
+        if (requestCode != REQUEST_CODE || pickerPromise == null) return
 
-        if (resultCode == Activity.RESULT_OK && data != null) {
-            val allSelectedUris = mutableListOf<Uri>()
-            data.clipData?.let { clip ->
+        if (resultCode == Activity.RESULT_OK) {
+            val uris = mutableListOf<Uri>()
+            
+            if (data?.clipData != null) {
+                val clip = data.clipData!!
                 for (i in 0 until clip.itemCount) {
-                    allSelectedUris.add(clip.getItemAt(i).uri)
+                    uris.add(clip.getItemAt(i).uri)
                 }
-            } ?: data.data?.let { uri ->
-                allSelectedUris.add(uri)
+            } else if (data?.data != null) {
+                uris.add(data.data!!)
             }
-            
-            val newSelectedUris = allSelectedUris.filter { uri -> !excludedUris.contains(uri.toString()) }
 
-            if (this.maxFiles > 0 && newSelectedUris.size > this.maxFiles) {
-                pickerPromise?.reject(E_MAX_FILES_EXCEEDED, "En fazla ${this.maxFiles} adet yeni dosya seçebilirsiniz.")
+            // Excluded URI Filtreleme
+            val filteredUris = uris.filter { !excludedUris.contains(it.toString()) }
+
+            if (filteredUris.size > maxFiles) {
+                pickerPromise?.reject("E_MAX_FILES", "Maksimum $maxFiles dosya seçebilirsiniz.")
                 pickerPromise = null
                 return
             }
 
             try {
-                val fileInfoArray = processSelectedFiles(newSelectedUris)
-                pickerPromise?.resolve(fileInfoArray)
+                val result = processSelectedFiles(filteredUris)
+                pickerPromise?.resolve(result)
             } catch (e: Exception) {
-                pickerPromise?.reject(E_FILE_TOO_LARGE, e.message)
+                pickerPromise?.reject("E_PROCESS_FAILED", e.message)
             }
         } else {
-            pickerPromise?.reject(E_PICKER_CANCELLED, "Dosya seçimi iptal edildi.")
+            pickerPromise?.reject("E_CANCELLED", "İptal edildi.")
         }
         pickerPromise = null
     }
 
-    override fun onNewIntent(intent: Intent) {}
+    override fun onNewIntent(intent: Intent?) {}
 
     private fun processSelectedFiles(uris: List<Uri>): WritableArray {
-        val fileObjects = WritableNativeArray()
+        val resultArr = WritableNativeArray()
         val maxSizeBytes = (maxSize * 1024 * 1024).toLong()
 
         for (uri in uris) {
             reactContext.contentResolver.query(uri, null, null, null, null)?.use { cursor ->
                 if (cursor.moveToFirst()) {
-                    val fileNameIndex = cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME)
-                    val fileSizeIndex = cursor.getColumnIndexOrThrow(OpenableColumns.SIZE)
-                    val fileName = cursor.getString(fileNameIndex)
-                    val fileSize = cursor.getLong(fileSizeIndex)
-
-                    if (maxSizeBytes > 0 && fileSize > maxSizeBytes) {
-                        throw Exception("Seçilen dosya ($fileName) belirtilen ${maxSize}MB boyutundan büyük.")
+                    val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
+                    val nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+                    
+                    val size = if(sizeIndex >= 0) cursor.getLong(sizeIndex) else 0L
+                    val name = if(nameIndex >= 0) cursor.getString(nameIndex) else "unknown"
+
+                    if (maxSizeBytes > 0 && size > maxSizeBytes) {
+                        throw Exception("Dosya ($name) boyutu çok büyük. Limit: ${maxSize}MB")
                     }
 
-                    val mimeType = getMimeType(fileName)
-                    val base64 = reactContext.contentResolver.openInputStream(uri)?.use { inputStream ->
-                        val byteBuffer = ByteArrayOutputStream()
-                        val buffer = ByteArray(1024)
-                        var len: Int
-                        while (inputStream.read(buffer).also { len = it } != -1) {
-                            byteBuffer.write(buffer, 0, len)
-                        }
-                        Base64.encodeToString(byteBuffer.toByteArray(), Base64.NO_WRAP)
-                    }
-
-                    val fileMap = WritableNativeMap().apply {
-                        putString("fileName", fileName)
-                        putDouble("fileSize", fileSize.toDouble())
-                        putString("fileType", mimeType)
-                        putString("fileUri", uri.toString())
-                        putString("base64", base64)
-                    }
-                    fileObjects.pushMap(fileMap)
+                    // Base64 okuma
+                    val base64 = reactContext.contentResolver.openInputStream(uri)?.use { stream ->
+                        val bytes = stream.readBytes()
+                        Base64.encodeToString(bytes, Base64.NO_WRAP)
+                    } ?: ""
+                    
+                    val mimeType = reactContext.contentResolver.getType(uri) ?: "application/octet-stream"
+
+                    val map = WritableNativeMap()
+                    map.putString("uri", uri.toString())
+                    map.putString("name", name)
+                    map.putString("type", mimeType)
+                    map.putDouble("size", size.toDouble())
+                    map.putString("base64", base64)
+                    
+                    resultArr.pushMap(map)
                 }
             }
         }
-        return fileObjects
+        return resultArr
     }
-    
-    private fun getMimeType(fileName: String): String? = URLConnection.guessContentTypeFromName(fileName)
 }

package/android/src/main/java/com/myuploaderandroid/MyUploaderPackage.kt

@@ -8,7 +8,7 @@ import com.facebook.react.uimanager.ViewManager
 class MyUploaderPackage : ReactPackage {
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
         return listOf(
-            MyUploaderModule(reactContext)
+            MyUploaderModule(reactContext),
             DownloadFileModule(reactContext)
             )
     }

package/lib/commonjs/NativeModules.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NativePicker = exports.NativeDownload = void 0;
+var _reactNative = require("react-native");
+const {
+  DownloadFile,
+  DocumentPicker
+} = _reactNative.NativeModules;
+if (!DownloadFile) console.warn("MyUploader: DownloadFile native module not found.");
+if (!DocumentPicker) console.warn("MyUploader: DocumentPicker native module not found.");
+const NativeDownload = exports.NativeDownload = DownloadFile;
+const NativePicker = exports.NativePicker = DocumentPicker;
+//# sourceMappingURL=NativeModules.js.map

package/lib/commonjs/NativeModules.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","DownloadFile","DocumentPicker","NativeModules","console","warn","NativeDownload","exports","NativePicker"],"sources":["NativeModules.ts"],"sourcesContent":["import { NativeModules } from 'react-native';\r\n\r\nconst { DownloadFile, DocumentPicker } = NativeModules;\r\n\r\nif (!DownloadFile) console.warn(\"MyUploader: DownloadFile native module not found.\");\r\nif (!DocumentPicker) console.warn(\"MyUploader: DocumentPicker native module not found.\");\r\n\r\nexport const NativeDownload = DownloadFile;\r\nexport const NativePicker = DocumentPicker;"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,MAAM;EAAEC,YAAY;EAAEC;AAAe,CAAC,GAAGC,0BAAa;AAEtD,IAAI,CAACF,YAAY,EAAEG,OAAO,CAACC,IAAI,CAAC,mDAAmD,CAAC;AACpF,IAAI,CAACH,cAAc,EAAEE,OAAO,CAACC,IAAI,CAAC,qDAAqD,CAAC;AAEjF,MAAMC,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAGL,YAAY;AACnC,MAAMO,YAAY,GAAAD,OAAA,CAAAC,YAAA,GAAGN,cAAc","ignoreList":[]}

package/lib/commonjs/components/DownloadFile.js

@@ -6,13 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _react = _interopRequireWildcard(require("react"));
 var _reactNative = require("react-native");
+var _NativeModules = require("../NativeModules");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-const {
-  DownloadFile: DownloadFileModule
-} = _reactNative.NativeModules;
 const DownloadFile = ({
   files,
-  multipleLoad = false,
+  multipleDownload = false,
   disabled = false,
   debug = false,
   maxSize = 0,
@@ -21,82 +19,72 @@ const DownloadFile = ({
   buttonIcon,
   ButtonStyle,
   ButtonTextStyle,
-  onSuccess = () => {},
-  onError = error => console.error('DownloadFile Error:', error)
+  onSuccess,
+  onError
 }) => {
   const [isLoading, setIsLoading] = (0, _react.useState)(false);
   const handlePress = async () => {
-    if (!DownloadFileModule) {
-      onError(new Error("DownloadFile native module is not available."));
-      return;
-    }
+    if (disabled || isLoading || !files.length) return;
     setIsLoading(true);
-    const downloadOptions = {
+    const options = {
+      debug,
       maxSize,
-      fileTypes,
-      debug
+      fileTypes
     };
+    const targetFiles = multipleDownload ? files : [files[0]];
     try {
-      const filesToProcess = multipleLoad ? files : files.slice(0, 1);
-      const downloadPromises = filesToProcess.map(url => DownloadFileModule.downloadFile(url, downloadOptions));
-      const settledResults = await Promise.allSettled(downloadPromises);
-      const finalResult = {
+      const promises = targetFiles.map(url => _NativeModules.NativeDownload.downloadFile(url, options));
+      const results = await Promise.allSettled(promises);
+      const final = {
         successful: [],
         skipped: []
       };
-      settledResults.forEach((result, index) => {
-        // DÜZELTME: `filesToProcess[index]` ifadesinin sonuna `!` ekleyerek
-        // TypeScript'e bu değerin asla undefined olmayacağını bildiriyoruz.
-        const originalUrl = filesToProcess[index];
-        if (result.status === 'fulfilled') {
-          finalResult.successful.push({
+      results.forEach((res, index) => {
+        var _targetFiles$index;
+        const originalUrl = (_targetFiles$index = targetFiles[index]) !== null && _targetFiles$index !== void 0 ? _targetFiles$index : "";
+        if (res.status === 'fulfilled') {
+          final.successful.push({
             originalUrl,
-            // Artık hata vermeyecek
-            localUri: result.value
+            localUri: res.value
           });
         } else {
-          finalResult.skipped.push({
+          var _res$reason;
+          final.skipped.push({
             originalUrl,
-            // Artık hata vermeyecek
-            reason: result.reason.message
+            reason: ((_res$reason = res.reason) === null || _res$reason === void 0 ? void 0 : _res$reason.message) || "Bilinmeyen Hata"
           });
         }
       });
-      onSuccess(finalResult);
-    } catch (error) {
-      onError(error);
+      if (onSuccess) onSuccess(final);
+    } catch (e) {
+      if (onError) onError(e);else console.error(e);
     } finally {
       setIsLoading(false);
     }
   };
-  const content = isLoading ? /*#__PURE__*/_react.default.createElement(_reactNative.ActivityIndicator, {
-    color: "#FFFFFF"
-  }) : buttonIcon || /*#__PURE__*/_react.default.createElement(_reactNative.Text, {
-    style: [styles.buttonText, ButtonTextStyle]
-  }, buttonPlaceHolder);
   return /*#__PURE__*/_react.default.createElement(_reactNative.TouchableOpacity, {
-    style: [styles.button, ButtonStyle, (disabled || isLoading) && styles.disabledButton],
+    style: [styles.button, ButtonStyle, (disabled || isLoading) && styles.disabled],
     onPress: handlePress,
     disabled: disabled || isLoading
-  }, content);
+  }, isLoading ? /*#__PURE__*/_react.default.createElement(_reactNative.ActivityIndicator, {
+    color: "#FFF"
+  }) : buttonIcon ? buttonIcon : /*#__PURE__*/_react.default.createElement(_reactNative.Text, {
+    style: [styles.text, ButtonTextStyle]
+  }, buttonPlaceHolder));
 };
 const styles = _reactNative.StyleSheet.create({
   button: {
-    backgroundColor: '#008CBA',
-    paddingHorizontal: 20,
-    paddingVertical: 10,
+    backgroundColor: '#03DAC6',
+    padding: 12,
     borderRadius: 8,
-    alignItems: 'center',
-    justifyContent: 'center',
-    flexDirection: 'row'
+    alignItems: 'center'
   },
-  buttonText: {
-    color: '#FFFFFF',
-    fontSize: 16,
+  text: {
+    color: '#000',
     fontWeight: 'bold'
   },
-  disabledButton: {
-    backgroundColor: '#A9A9A9'
+  disabled: {
+    backgroundColor: '#AAA'
   }
 });
 var _default = exports.default = DownloadFile;