rn-file-toolkit 1.0.2 → 1.0.4

package/README.md

@@ -1,68 +1,119 @@
-# rn-file-toolkit
+<div align="center">
+  <h1>rn-file-toolkit 🗂️</h1>
+  <p><b>The ultimate, unified native file management toolkit for React Native & Expo</b></p>
+  
+  [![npm version](https://img.shields.io/npm/v/rn-file-toolkit.svg?style=for-the-badge&color=success)](https://www.npmjs.com/package/rn-file-toolkit)
+  [![npm downloads](https://img.shields.io/npm/dt/rn-file-toolkit.svg?style=for-the-badge)](https://www.npmjs.com/package/rn-file-toolkit)
+  [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg?style=for-the-badge&logo=typescript)](https://www.typescriptlang.org/)
+  [![platforms](https://img.shields.io/badge/Platforms-iOS%20%7C%20Android-lightgrey.svg?style=for-the-badge&logo=apple&logoColor=white)](https://github.com/chavan-labs/rn-file-toolkit)
+  [![license](https://img.shields.io/npm/l/rn-file-toolkit.svg?style=for-the-badge)](https://github.com/chavan-labs/rn-file-toolkit/blob/main/LICENSE)
+</div>
 
-[![npm version](https://img.shields.io/npm/v/rn-file-toolkit.svg?style=flat-square)](https://www.npmjs.com/package/rn-file-toolkit)
-[![npm downloads](https://img.shields.io/npm/dm/rn-file-toolkit.svg?style=flat-square)](https://www.npmjs.com/package/rn-file-toolkit)
-[![license](https://img.shields.io/npm/l/rn-file-toolkit.svg?style=flat-square)](https://github.com/chavan-labs/rn-file-toolkit/blob/main/LICENSE)
-[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg?style=flat-square)](https://www.typescriptlang.org/)
-[![platforms](https://img.shields.io/badge/platforms-iOS%20%7C%20Android-lightgrey.svg?style=flat-square)](https://github.com/chavan-labs/rn-file-toolkit)
+---
+
+**rn-file-toolkit** is the modern replacement for legacy file libraries. Download, upload, manage queues, extract archives, and interact with the filesystem—all powered by pure native implementations (Kotlin + Swift) with **zero third-party dependencies**.
+
+⭐ **Star this repo if you find it useful to help others discover it!**
+
+## 📖 Table of Contents
+- [Why rn-file-toolkit?](#-why-rn-file-toolkit)
+- [Why not Expo FileSystem?](#-why-not-expo-filesystem)
+- [Installation](#-installation)
+- [Quick Start: `useDownload`](#-quick-start-usedownload)
+- [Core APIs](#-core-apis)
+  - [Background Downloads](#background-downloads)
+  - [Multipart Uploads](#multipart-uploads)
+  - [File System (FS)](#file-system-fs)
+  - [Zip & Unzip Archives](#zip--unzip-archives)
+  - [Media & Utilities](#media--utilities)
+- [API Reference](#-api-reference)
+- [Expo Support](#-expo-support)
+- [Contributing](#-contributing)
+
+---
 
-The ultimate, unified file management library for React Native. Download, upload, manage queues, and interact with the filesystem—all powered by pure native implementations (Kotlin + Swift) with **zero third-party dependencies**.
+## 🚀 Why rn-file-toolkit?
 
-⭐ **Star this repo if you found it useful!**
+Most React Native file solutions (`rn-fetch-blob`, `react-native-fs`) are fragmented, lightly maintained, or lack modern features. **rn-file-toolkit** gives you a unified, **TurboModule-compatible** API utilizing OS-native managers (`URLSession` on iOS, `DownloadManager` on Android) for reliable, battery-efficient operations.
+
+### ✨ Highlights
+- 🪝 **Drop-in React Hooks:** Built-in state management (`useDownload`) for progress and controls.
+- 📥 **Background Ready:** Downloads and uploads survive app suspension with automatic re-attachment.
+- 🚦 **Smart Queueing:** Cap concurrency and set priorities without touching native code.
+- 🛡️ **Resilient:** Auto-retries on network errors with exponential backoff and HTTP resume.
+- 🗜️ **Zero-Dependency Zip:** Uses native `java.util.zip` and iOS `zlib`.
+- 🗄️ **Rich File System API:** Comprehensive FS methods (`readFile`, `writeFile`, `copyFile`, `mkdir`, `stat`, etc.).
+- 🛠️ **Expo Compatible:** Seamless integration with Expo custom dev clients.
 
 ---
 
-## Why rn-file-toolkit?
-Most React Native file solutions are fragmented, bloated, or lack critical features like background queues or stable pause/resume. **rn-file-toolkit** gives you a unified, TurboModule-powered API utilizing OS-native download managers (`URLSession` on iOS, `DownloadManager` on Android) for reliable, battery-efficient file operations.
+## 🤔 Why not Expo FileSystem?
+
+Many developers looking for an **"expo-file-system alternative"** or a **"better react native download manager"** come here. While Expo FileSystem is a great tool for basic file operations, `rn-file-toolkit` is built specifically to handle complex, real-world file management scenarios:
 
-### ✨ Key Features
-- **Drop-in `useDownload()` Hook:** Built-in state management (`status`, `progress`, `result`) and controls (`pause`, `resume`, `cancel`).
-- **Background Downloads:** Survives app suspension with automatic re-attachment capabilities.
-- **Smart Queueing:** Cap concurrency and set priorities (`high`/`normal`) without native configuration.
-- **Resilient:** Auto-retries on network errors with exponential backoff and Range-based HTTP resume.
-- **Zero-Dependency Zip/Unzip:** Uses native `java.util.zip` and iOS `zlib` for extracting/compressing files.
-- **Rich File System API:** `readFile`, `writeFile`, `copyFile`, `moveFile`, `mkdir`, `ls`, `stat`, `exists`, and `deleteFile`.
-- **Media Utilities:** Base64 encoding/decoding, URL to Base64 conversions, and native share/open dialogs.
+- **Queueing & Concurrency:** Built-in smart queueing allows you to cap concurrent downloads and set priorities without writing complex JavaScript wrappers.
+- **Native Download/Upload Managers:** We hook directly into OS-level managers (`URLSession` on iOS, `DownloadManager` on Android) for maximum reliability and battery efficiency.
+- **Auto-Retries & Resiliency:** Native implementations handle network drops with exponential backoff and HTTP resume automatically.
+- **Multipart Uploads:** Robust, memory-efficient multipart uploads for large media are built right in.
+- **Drop-in React Hooks:** Provides a `useDownload` hook out-of-the-box for instant progress tracking, speed, ETA, and state controls.
+- **Background Persistence:** Downloads and uploads survive app suspension and backgrounding, automatically re-attaching when the app resumes.
 
 ---
 
-## Installation
+## 📦 Installation
 
-```sh
+```bash
+# npm
 npm install rn-file-toolkit
+
+# yarn
+yarn add rn-file-toolkit
+
+# pnpm
+pnpm add rn-file-toolkit
 ```
 
+*(Optional) If you are not using Expo or an auto-linking setup, run `pod install` in your `ios` directory.*
+
 ---
 
-## Quick Start: `useDownload` Hook
+## ⚡ Quick Start: `useDownload`
 
-The easiest way to manage a download inside a React component. Get status, rich progress (with speed & ETA), and full controls out of the box.
+The easiest way to manage a download inside a React component. Get status, rich progress (with speed & ETA), and full controls instantly.
 
 ```tsx
+import React from 'react';
+import { View, Text, Button } from 'react-native';
 import { useDownload } from 'rn-file-toolkit';
 
-function DownloadScreen() {
+export default function DownloadScreen() {
   const { start, pause, resume, cancel, status, progress, result } = useDownload();
 
   return (
-    <View>
+    <View style={{ padding: 20 }}>
       <Button 
-        title="Download" 
-        onPress={() => start({ url: 'https://example.com/video.mp4', destination: 'documents' })} 
+        title="Start Download" 
+        onPress={() => start({ 
+          url: 'https://example.com/large-video.mp4', 
+          destination: 'documents' 
+        })} 
       />
 
       {status === 'downloading' && progress && (
-        <View>
-          <Text>{progress.percent.toFixed(1)}% ({(progress.speedBps / 1024).toFixed(1)} KB/s)</Text>
-          <Text>ETA: {progress.etaSeconds.toFixed(0)}s</Text>
-          <Button title="Pause" onPress={pause} />
-          <Button title="Cancel" onPress={cancel} />
+        <View style={{ marginTop: 20 }}>
+          <Text>Progress: {progress.percent.toFixed(1)}%</Text>
+          <Text>Speed: {(progress.speedBps / 1024 / 1024).toFixed(2)} MB/s</Text>
+          <Text>ETA: {progress.etaSeconds.toFixed(0)} seconds</Text>
+          <View style={{ flexDirection: 'row', gap: 10, marginTop: 10 }}>
+            <Button title="Pause" onPress={pause} />
+            <Button title="Cancel" onPress={cancel} color="red" />
+          </View>
         </View>
       )}
 
       {status === 'paused' && <Button title="Resume" onPress={resume} />}
-      {status === 'done' && <Text>✅ Saved to: {result?.filePath}</Text>}
-      {status === 'error' && <Text>❌ {result?.error}</Text>}
+      {status === 'done' && <Text style={{ color: 'green' }}>✅ Saved: {result?.filePath}</Text>}
+      {status === 'error' && <Text style={{ color: 'red' }}>❌ Error: {result?.error}</Text>}
     </View>
   );
 }
@@ -70,103 +121,136 @@ function DownloadScreen() {
 
 ---
 
-## Core APIs
+## 🛠️ Core APIs
 
-### `download(options)`
-For programmatic, queue-aware background downloads.
+### Background Downloads
+For programmatic, queue-aware background downloads outside of React components.
 
-```javascript
+```typescript
 import { download, setQueueOptions } from 'rn-file-toolkit';
 
-// Optional: Configure global concurrency queue
+// Optimize global concurrency
 setQueueOptions({ maxConcurrent: 3 });
 
 const result = await download({
   url: 'https://example.com/file.pdf',
   destination: 'documents', // 'downloads' | 'cache' | 'documents'
-  queue: true, // Joins the managed queue
-  priority: 'high', // 'high' | 'normal'
+  queue: true,              // Join the managed queue
+  priority: 'high',         // 'high' | 'normal'
   retry: { attempts: 3, delay: 1000 },
-  checksum: { hash: 'd41d8cd...', algorithm: 'md5' },
-  onProgress: (p) => console.log(`${p.percent.toFixed(1)}%`),
+  onProgress: (p) => console.log(`${p.percent.toFixed(1)}% downloaded`),
 });
 ```
 
-### `upload(options)`
-Robust, memory-efficient multipart file uploading.
+### Multipart Uploads
+Robust, memory-efficient multipart file uploading for large media or documents.
 
-```javascript
+```typescript
 import { upload } from 'rn-file-toolkit';
 
 const result = await upload({
-  url: 'https://example.com/api/upload',
-  filePath: '/path/to/my_image.jpg',
-  fieldName: 'avatar',
-  parameters: { userId: '123' },
-  onProgress: (p) => console.log(`Uploading: ${p}%`),
+  url: 'https://api.example.com/v1/upload',
+  filePath: '/path/to/local/image.jpg',
+  fieldName: 'file',
+  parameters: { userId: '123', folder: 'avatars' },
+  onProgress: (percent) => console.log(`Uploading: ${percent}%`),
 });
 ```
 
-### Filesystem (`fs`)
-Perform native filesystem operations directly.
+### File System (FS)
+Perform native filesystem operations securely.
 
-```javascript
+```typescript
 import { fs } from 'rn-file-toolkit';
 
-await fs.exists('/path/to/file.txt');
-await fs.stat('/path/to/file.txt'); // { size, modified, isDir ... }
-await fs.writeFile('/path/to/file.txt', 'hello', 'utf8'); // Supports 'base64'
-await fs.copyFile('/src/file.txt', '/dst/file.txt');
-await fs.mkdir('/path/to/folder');
-const files = await fs.ls('/path/to/folder');
+// Check & Inspect
+const exists = await fs.exists('/path/to/data.json');
+const stats = await fs.stat('/path/to/data.json'); // { size, modified, isDir }
+
+// Read & Write
+await fs.writeFile('/path/to/data.txt', 'Hello World', 'utf8'); // Also supports 'base64'
+const content = await fs.readFile('/path/to/data.txt', 'utf8');
+
+// Manage Folders & Files
+await fs.mkdir('/path/to/new_folder');
+const files = await fs.ls('/path/to/new_folder');
+await fs.copyFile('/path/src.txt', '/path/dest.txt');
+await fs.moveFile('/path/old.txt', '/path/new.txt');
+await fs.deleteFile('/path/unwanted.txt');
 ```
 
-### Zip & Unzip
-Compress and extract archives securely.
+### Zip & Unzip Archives
+Compress and extract archives directly on the device.
 
-```javascript
+```typescript
 import { unzip, zip } from 'rn-file-toolkit';
 
-await unzip('/path/to/assets.zip', '/path/to/output-folder');
-await zip('/path/to/document.pdf', '/path/to/document.zip');
+// Extract a downloaded zip
+await unzip('/path/to/bundle.zip', '/path/to/extract-folder');
+
+// Compress user data before uploading
+await zip('/path/to/user-data-folder', '/path/to/backup.zip');
 ```
 
 ### Media & Utilities
+Helpful tools for sharing, opening, and encoding files.
 
-```javascript
+```typescript
 import { saveBase64AsFile, urlToBase64, shareFile, openFile } from 'rn-file-toolkit';
 
-// Convert base64 / Data URIs to files
-await saveBase64AsFile({ base64Data: 'data:image/png;base64,...', destination: 'documents' });
+// Base64 to File
+await saveBase64AsFile({ 
+  base64Data: 'data:image/png;base64,...', 
+  destination: 'documents',
+  fileName: 'image.png'
+});
 
-// Fetch remote media as base64
-await urlToBase64({ url: 'https://example.com/photo.jpg' });
+// URL to Base64 (Great for caching small images)
+const b64 = await urlToBase64({ url: 'https://example.com/icon.png' });
 
-// Share with native dialog
-await shareFile({ filePath: '/path/to/document.pdf' });
+// Native Share Sheet
+await shareFile({ filePath: '/path/to/report.pdf' });
 
-// Open with default app
-await openFile({ filePath: '/path/to/document.pdf', mimeType: 'application/pdf' });
+// Open with default system app
+await openFile({ filePath: '/path/to/report.pdf', mimeType: 'application/pdf' });
 ```
 
 ---
 
-## API Type Reference
-
-| Type                 | Fields |
-| -------------------- | ------ |
-| `DownloadOptions`    | `url`, `fileName?`, `background?`, `headers?`, `destination?`, `notificationTitle?`, `notificationDescription?`, `checksum?`, `onProgress?`, `retry?`, `queue?`, `priority?` |
-| `ProgressInfo`       | `percent`, `bytesDownloaded`, `totalBytes`, `speedBps`, `etaSeconds` |
-| `RetryOptions`       | `attempts`, `delay?`, `onRetry?` |
-| `QueueOptions`       | `maxConcurrent?` |
-| `DownloadResult`     | `success`, `filePath?`, `downloadId?`, `error?` |
-| `UploadOptions`      | `url`, `filePath`, `fieldName?`, `headers?`, `parameters?`, `onProgress?`, `uploadId?` |
-| `UploadResult`       | `success`, `status?`, `data?`, `error?`, `uploadId?` |
-| `UseDownloadReturn`  | `start`, `pause`, `resume`, `cancel`, `status`, `progress`, `result`, `downloadId` |
-| `FsStat`             | `path`, `name`, `size`, `modified`, `isDir` |
-| `UnzipResult`        | `success`, `destDir?`, `files?`, `error?` |
-| `ZipResult`          | `success`, `zipPath?`, `error?` |
+## 📚 API Reference
+
+| Interface | Key Properties | Description |
+| :--- | :--- | :--- |
+| `DownloadOptions` | `url`, `destination`, `queue`, `retry`, `onProgress` | Configuration for downloading a file. |
+| `UploadOptions` | `url`, `filePath`, `fieldName`, `parameters`, `onProgress` | Configuration for multipart uploads. |
+| `ProgressInfo` | `percent`, `bytesDownloaded`, `speedBps`, `etaSeconds` | Rich real-time progress payload. |
+| `UseDownloadReturn` | `start`, `pause`, `resume`, `cancel`, `status`, `progress` | Hook state and control methods. |
+| `FsStat` | `size`, `modified`, `isDir` | Output of the filesystem `stat` method. |
+
+*For advanced types and detailed parameter documentation, please refer to the source TypeScript definitions.*
+
+---
+
+## 🎪 Expo Support
+
+**rn-file-toolkit** works seamlessly with Expo custom development clients (EAS Build / `npx expo run:android` / `npx expo run:ios`). Since it contains native code, it is not compatible with Expo Go. 
+
+An Expo config plugin is included automatically. No extra configuration is needed in your `app.json` unless you want to customize permissions.
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! If you find a bug or want to request a feature, please [open an issue](https://github.com/chavan-labs/rn-file-toolkit/issues). 
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
 
 ---
 
-_Made natively for the community 🤝 by Rohit Chavan_
+<div align="center">
+  <i>Built with ❤️ for the React Native community by <a href="https://github.com/chavanRk">Rohit Chavan</a></i>
+</div>

package/android/src/main/java/com/filetoolkit/FileToolkitModule.kt

@@ -598,7 +598,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
         putBoolean("success", true)
         putBoolean("exists", file.exists())
       })
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", false)
         putString("error", e.message ?: "EXISTS_ERROR")
@@ -629,7 +629,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
           putDouble("modified", file.lastModified().toDouble())
         })
       })
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", false)
         putString("error", e.message ?: "STAT_ERROR")
@@ -650,6 +650,15 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
         return
       }
 
+      // Safety check: reject files > 50MB to prevent crashing the RN bridge
+      if (file.length() > 50L * 1024 * 1024) {
+        promise.resolve(Arguments.createMap().apply {
+          putBoolean("success", false)
+          putString("error", "File exceeds 50MB limit for readFile. Use streaming or base64 encoding for large files.")
+        })
+        return
+      }
+
       val data = if (encoding.equals("base64", ignoreCase = true)) {
         android.util.Base64.encodeToString(file.readBytes(), android.util.Base64.NO_WRAP)
       } else {
@@ -660,7 +669,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
         putBoolean("success", true)
         putString("data", data)
       })
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", false)
         putString("error", e.message ?: "READ_FILE_ERROR")
@@ -685,7 +694,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", true)
       })
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", false)
         putString("error", e.message ?: "WRITE_FILE_ERROR")
@@ -713,7 +722,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", true)
       })
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", false)
         putString("error", e.message ?: "COPY_FILE_ERROR")
@@ -753,7 +762,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", true)
       })
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", false)
         putString("error", e.message ?: "MOVE_FILE_ERROR")
@@ -771,7 +780,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
         putBoolean("success", ok)
         if (!ok) putString("error", "Could not create directory: $dirPath")
       })
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", false)
         putString("error", e.message ?: "MKDIR_ERROR")
@@ -799,7 +808,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
         putBoolean("success", true)
         putArray("entries", entries)
       })
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", false)
         putString("error", e.message ?: "LS_ERROR")
@@ -1018,7 +1027,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
         putString("filePath", destFile.absolutePath)
       })
 
-    } catch (e: Exception) {
+    } catch (e: Throwable) {
       promise.resolve(Arguments.createMap().apply {
         putBoolean("success", false)
         putString("error", e.message ?: "BASE64_SAVE_ERROR")
@@ -1079,7 +1088,7 @@ class FileToolkitModule(private val reactContext: ReactApplicationContext) :
           putString("dataUri", "data:$mimeType;base64,$base64String")
         })
 
-      } catch (e: Exception) {
+      } catch (e: Throwable) {
         promise.resolve(Arguments.createMap().apply {
           putBoolean("success", false)
           putString("error", e.message ?: "URL_TO_BASE64_ERROR")

package/ios/FileToolkit.mm

@@ -376,6 +376,14 @@ RCT_EXPORT_MODULE()
         return;
     }
 
+    // Safety check: reject files > 50MB to prevent crashing the RN bridge
+    NSDictionary *attrs = [fm attributesOfItemAtPath:filePath error:nil];
+    unsigned long long fileSize = [attrs fileSize];
+    if (fileSize > 50 * 1024 * 1024) {
+        resolve(@{@"success": @NO, @"error": @"File exceeds 50MB limit for readFile. Use streaming or base64 encoding for large files."});
+        return;
+    }
+
     NSError *readError = nil;
     NSData *raw = [NSData dataWithContentsOfFile:filePath options:0 error:&readError];
     if (!raw || readError) {
@@ -1155,9 +1163,10 @@ RCT_EXPORT_METHOD(unzip:(NSString *)sourcePath
         // pure-Foundation approach using NSInputStream with a known zip local-file header parser.
 
         // ── Pure-Foundation zip reader (no third-party, no subprocess) ──────────
-        NSData *zipData = [NSData dataWithContentsOfFile:sourcePath];
+        NSError *readError = nil;
+        NSData *zipData = [NSData dataWithContentsOfFile:sourcePath options:NSDataReadingMappedIfSafe error:&readError];
         if (!zipData) {
-            resolve(@{@"success": @NO, @"error": @"Cannot read zip file"});
+            resolve(@{@"success": @NO, @"error": readError.localizedDescription ?: @"Cannot read zip file"});
             return;
         }
 
@@ -1342,7 +1351,14 @@ RCT_EXPORT_METHOD(zip:(NSString *)sourcePath
         // Delete existing destination file
         [fm removeItemAtPath:destPath error:nil];
 
-        NSMutableData *zipData = [NSMutableData new];
+        // Create the destination file and open a handle for writing
+        [fm createFileAtPath:destPath contents:nil attributes:nil];
+        NSFileHandle *fh = [NSFileHandle fileHandleForWritingAtPath:destPath];
+        if (!fh) {
+            resolve(@{@"success": @NO, @"error": @"Failed to create destination zip file"});
+            return;
+        }
+
         NSMutableArray<NSDictionary *> *centralDirectory = [NSMutableArray new];
 
         NSArray<NSString *> *filesToZip;
@@ -1352,9 +1368,6 @@ RCT_EXPORT_METHOD(zip:(NSString *)sourcePath
             NSMutableArray *files = [NSMutableArray new];
             NSString *file;
             while ((file = [enumerator nextObject])) {
-                NSString *fullPath = [sourcePath stringByAppendingPathComponent:file];
-                BOOL entryIsDir = NO;
-                [fm fileExistsAtPath:fullPath isDirectory:&entryIsDir];
                 [files addObject:file];
             }
             filesToZip = files;
@@ -1369,80 +1382,138 @@ RCT_EXPORT_METHOD(zip:(NSString *)sourcePath
             BOOL entryIsDir = NO;
             [fm fileExistsAtPath:fullPath isDirectory:&entryIsDir];
 
-            NSData *fileData = entryIsDir ? [NSData data] : [NSData dataWithContentsOfFile:fullPath];
-            if (!fileData) continue;
-
             NSData *entryNameData = [relativePath dataUsingEncoding:NSUTF8StringEncoding];
             uint16_t nameLen = (uint16_t)entryNameData.length;
 
-            // Deflate compress (skip compression for directories)
-            NSData *compressedData;
-            uint16_t method;
+            uint32_t localHeaderOffset = (uint32_t)[fh offsetInFile];
+
+            // Write local file header with placeholder CRC/sizes
+            uint32_t sig       = CFSwapInt32HostToLittle(0x04034b50);
+            uint16_t version   = CFSwapInt16HostToLittle(20);
+            uint16_t flags     = 0;
+            uint16_t modTime   = 0, modDate = 0;
+            uint16_t extraLen  = 0;
+
+            // Placeholders — will be patched after streaming
+            uint16_t method    = 0;
+            uint32_t crcLE     = 0;
+            uint32_t compSz    = 0;
+            uint32_t uncompSz  = 0;
+
+            [fh writeData:[NSData dataWithBytes:&sig       length:4]];
+            [fh writeData:[NSData dataWithBytes:&version   length:2]];
+            [fh writeData:[NSData dataWithBytes:&flags     length:2]];
+            [fh writeData:[NSData dataWithBytes:&method    length:2]]; // offset +8
+            [fh writeData:[NSData dataWithBytes:&modTime   length:2]];
+            [fh writeData:[NSData dataWithBytes:&modDate   length:2]];
+            [fh writeData:[NSData dataWithBytes:&crcLE     length:4]]; // offset +14
+            [fh writeData:[NSData dataWithBytes:&compSz    length:4]]; // offset +18
+            [fh writeData:[NSData dataWithBytes:&uncompSz  length:4]]; // offset +22
+            [fh writeData:[NSData dataWithBytes:&nameLen   length:2]];
+            [fh writeData:[NSData dataWithBytes:&extraLen  length:2]];
+            [fh writeData:entryNameData];
+
             uint32_t crc = 0;
+            uint32_t compressedSize = 0;
+            uint32_t uncompressedSize = 0;
+            uint16_t compressionMethod = 0;
 
-            if (entryIsDir || fileData.length == 0) {
-                compressedData = fileData;
-                method = 0;
+            if (entryIsDir) {
+                // Directory entry — no data to write
             } else {
-                // zlib deflate (raw, -15)
-                uLongf bound = compressBound((uLong)fileData.length);
-                NSMutableData *comp = [NSMutableData dataWithLength:bound];
+                NSInputStream *inputStream = [NSInputStream inputStreamWithFileAtPath:fullPath];
+                [inputStream open];
+
+                if (!inputStream || inputStream.streamStatus == NSStreamStatusError) {
+                    [inputStream close];
+                    continue;
+                }
+
+                // Stream-compress with zlib deflate
                 z_stream strm;
                 memset(&strm, 0, sizeof(strm));
-                strm.next_in   = (Bytef *)fileData.bytes;
-                strm.avail_in  = (uInt)fileData.length;
-                strm.next_out  = (Bytef *)comp.mutableBytes;
-                strm.avail_out = (uInt)bound;
                 deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
-                deflate(&strm, Z_FINISH);
+
+                uint8_t inBuf[32768];
+                uint8_t outBuf[32768];
+                int flush = Z_NO_FLUSH;
+
+                while ([inputStream hasBytesAvailable]) {
+                    NSInteger bytesRead = [inputStream read:inBuf maxLength:sizeof(inBuf)];
+                    if (bytesRead <= 0) break;
+
+                    crc = (uint32_t)crc32((uLong)crc, inBuf, (uInt)bytesRead);
+                    uncompressedSize += (uint32_t)bytesRead;
+
+                    strm.next_in = inBuf;
+                    strm.avail_in = (uInt)bytesRead;
+
+                    if (![inputStream hasBytesAvailable]) {
+                        flush = Z_FINISH;
+                    }
+
+                    do {
+                        strm.next_out = outBuf;
+                        strm.avail_out = sizeof(outBuf);
+                        deflate(&strm, flush);
+                        NSUInteger produced = sizeof(outBuf) - strm.avail_out;
+                        if (produced > 0) {
+                            [fh writeData:[NSData dataWithBytes:outBuf length:produced]];
+                            compressedSize += (uint32_t)produced;
+                        }
+                    } while (strm.avail_out == 0);
+                }
+
+                // Finalize deflate if we didn't hit Z_FINISH yet
+                if (flush != Z_FINISH) {
+                    strm.next_in = NULL;
+                    strm.avail_in = 0;
+                    do {
+                        strm.next_out = outBuf;
+                        strm.avail_out = sizeof(outBuf);
+                        deflate(&strm, Z_FINISH);
+                        NSUInteger produced = sizeof(outBuf) - strm.avail_out;
+                        if (produced > 0) {
+                            [fh writeData:[NSData dataWithBytes:outBuf length:produced]];
+                            compressedSize += (uint32_t)produced;
+                        }
+                    } while (strm.avail_out == 0);
+                }
+
                 deflateEnd(&strm);
-                [comp setLength:strm.total_out];
-                compressedData = comp;
-                method = 8;
+                [inputStream close];
+                compressionMethod = 8;
             }
 
-            // CRC32
-            crc = (uint32_t)crc32(0L, (const Bytef *)fileData.bytes, (uInt)fileData.length);
-
-            uint32_t localHeaderOffset = (uint32_t)zipData.length;
+            // Patch the local file header with actual CRC, sizes, method
+            unsigned long long currentPos = [fh offsetInFile];
+            uint16_t methLE   = CFSwapInt16HostToLittle(compressionMethod);
+            uint32_t crcPatch = CFSwapInt32HostToLittle(crc);
+            uint32_t csPatch  = CFSwapInt32HostToLittle(compressedSize);
+            uint32_t usPatch  = CFSwapInt32HostToLittle(uncompressedSize);
 
-            // Local file header
-            uint32_t sig       = CFSwapInt32HostToLittle(0x04034b50);
-            uint16_t version   = CFSwapInt16HostToLittle(20);
-            uint16_t flags     = 0;
-            uint16_t meth      = CFSwapInt16HostToLittle(method);
-            uint16_t modTime   = 0, modDate = 0; // no time for simplicity
-            uint32_t crcLE     = CFSwapInt32HostToLittle(crc);
-            uint32_t compSz    = CFSwapInt32HostToLittle((uint32_t)compressedData.length);
-            uint32_t uncompSz  = CFSwapInt32HostToLittle((uint32_t)fileData.length);
-            uint16_t extraLen  = 0;
+            [fh seekToFileOffset:localHeaderOffset + 8];
+            [fh writeData:[NSData dataWithBytes:&methLE    length:2]];
+            [fh seekToFileOffset:localHeaderOffset + 10]; // skip modTime
+            [fh seekToFileOffset:localHeaderOffset + 14];
+            [fh writeData:[NSData dataWithBytes:&crcPatch  length:4]];
+            [fh writeData:[NSData dataWithBytes:&csPatch   length:4]];
+            [fh writeData:[NSData dataWithBytes:&usPatch   length:4]];
 
-            [zipData appendBytes:&sig       length:4];
-            [zipData appendBytes:&version   length:2];
-            [zipData appendBytes:&flags     length:2];
-            [zipData appendBytes:&meth      length:2];
-            [zipData appendBytes:&modTime   length:2];
-            [zipData appendBytes:&modDate   length:2];
-            [zipData appendBytes:&crcLE     length:4];
-            [zipData appendBytes:&compSz    length:4];
-            [zipData appendBytes:&uncompSz  length:4];
-            [zipData appendBytes:&nameLen   length:2];
-            [zipData appendBytes:&extraLen  length:2];
-            [zipData appendData:entryNameData];
-            [zipData appendData:compressedData];
+            [fh seekToFileOffset:currentPos]; // restore position
 
             [centralDirectory addObject:@{
                 @"name":            entryNameData,
-                @"method":          @(method),
+                @"method":          @(compressionMethod),
                 @"crc":             @(crc),
-                @"compSize":        @(compressedData.length),
-                @"uncompSize":      @(fileData.length),
+                @"compSize":        @(compressedSize),
+                @"uncompSize":      @(uncompressedSize),
                 @"localOffset":     @(localHeaderOffset),
             }];
         }
 
         // Central directory
-        uint32_t cdOffset = (uint32_t)zipData.length;
+        uint32_t cdOffset = (uint32_t)[fh offsetInFile];
         for (NSDictionary *entry in centralDirectory) {
             NSData *nameData = entry[@"name"];
             uint16_t nameLen = (uint16_t)nameData.length;
@@ -1461,27 +1532,27 @@ RCT_EXPORT_METHOD(zip:(NSString *)sourcePath
             uint32_t extAttr = 0;
             uint32_t localOff = CFSwapInt32HostToLittle((uint32_t)[entry[@"localOffset"] unsignedIntValue]);
 
-            [zipData appendBytes:&cdSig      length:4];
-            [zipData appendBytes:&verMade    length:2];
-            [zipData appendBytes:&verNeeded  length:2];
-            [zipData appendBytes:&flags      length:2];
-            [zipData appendBytes:&meth       length:2];
-            [zipData appendBytes:&modTime    length:2];
-            [zipData appendBytes:&modDate    length:2];
-            [zipData appendBytes:&crcLE      length:4];
-            [zipData appendBytes:&compSz     length:4];
-            [zipData appendBytes:&uncompSz   length:4];
-            [zipData appendBytes:&nameLen    length:2];
-            [zipData appendBytes:&extraLen   length:2];
-            [zipData appendBytes:&commentLen length:2];
-            [zipData appendBytes:&disk       length:2];
-            [zipData appendBytes:&intAttr    length:2];
-            [zipData appendBytes:&extAttr    length:4];
-            [zipData appendBytes:&localOff   length:4];
-            [zipData appendData:nameData];
+            [fh writeData:[NSData dataWithBytes:&cdSig      length:4]];
+            [fh writeData:[NSData dataWithBytes:&verMade    length:2]];
+            [fh writeData:[NSData dataWithBytes:&verNeeded  length:2]];
+            [fh writeData:[NSData dataWithBytes:&flags      length:2]];
+            [fh writeData:[NSData dataWithBytes:&meth       length:2]];
+            [fh writeData:[NSData dataWithBytes:&modTime    length:2]];
+            [fh writeData:[NSData dataWithBytes:&modDate    length:2]];
+            [fh writeData:[NSData dataWithBytes:&crcLE      length:4]];
+            [fh writeData:[NSData dataWithBytes:&compSz     length:4]];
+            [fh writeData:[NSData dataWithBytes:&uncompSz   length:4]];
+            [fh writeData:[NSData dataWithBytes:&nameLen    length:2]];
+            [fh writeData:[NSData dataWithBytes:&extraLen   length:2]];
+            [fh writeData:[NSData dataWithBytes:&commentLen length:2]];
+            [fh writeData:[NSData dataWithBytes:&disk       length:2]];
+            [fh writeData:[NSData dataWithBytes:&intAttr    length:2]];
+            [fh writeData:[NSData dataWithBytes:&extAttr    length:4]];
+            [fh writeData:[NSData dataWithBytes:&localOff   length:4]];
+            [fh writeData:nameData];
         }
 
-        uint32_t cdSize   = CFSwapInt32HostToLittle((uint32_t)(zipData.length - cdOffset));
+        uint32_t cdSize   = CFSwapInt32HostToLittle((uint32_t)([fh offsetInFile] - cdOffset));
         uint32_t cdOffLE  = CFSwapInt32HostToLittle(cdOffset);
         uint16_t numEntries = CFSwapInt16HostToLittle((uint16_t)centralDirectory.count);
         uint16_t commentLen = 0;
@@ -1489,21 +1560,17 @@ RCT_EXPORT_METHOD(zip:(NSString *)sourcePath
         // End of central directory record
         uint32_t eocdSig = CFSwapInt32HostToLittle(0x06054b50);
         uint16_t disk = 0;
-        [zipData appendBytes:&eocdSig    length:4];
-        [zipData appendBytes:&disk       length:2];
-        [zipData appendBytes:&disk       length:2];
-        [zipData appendBytes:&numEntries length:2];
-        [zipData appendBytes:&numEntries length:2];
-        [zipData appendBytes:&cdSize     length:4];
-        [zipData appendBytes:&cdOffLE    length:4];
-        [zipData appendBytes:&commentLen length:2];
-
-        NSError *writeErr = nil;
-        if ([zipData writeToFile:destPath options:NSDataWritingAtomic error:&writeErr]) {
-            resolve(@{@"success": @YES, @"zipPath": destPath});
-        } else {
-            resolve(@{@"success": @NO, @"error": writeErr.localizedDescription ?: @"ZIP_WRITE_ERROR"});
-        }
+        [fh writeData:[NSData dataWithBytes:&eocdSig    length:4]];
+        [fh writeData:[NSData dataWithBytes:&disk       length:2]];
+        [fh writeData:[NSData dataWithBytes:&disk       length:2]];
+        [fh writeData:[NSData dataWithBytes:&numEntries length:2]];
+        [fh writeData:[NSData dataWithBytes:&numEntries length:2]];
+        [fh writeData:[NSData dataWithBytes:&cdSize     length:4]];
+        [fh writeData:[NSData dataWithBytes:&cdOffLE    length:4]];
+        [fh writeData:[NSData dataWithBytes:&commentLen length:2]];
+
+        [fh closeFile];
+        resolve(@{@"success": @YES, @"zipPath": destPath});
     });
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rn-file-toolkit",
-  "version": "1.0.2",
-  "description": "The simplest and most reliable way to download files in React Native with progress, permissions, and file handling built-in.",
+  "version": "1.0.4",
+  "description": "The ultimate native file management toolkit for React Native. Features background downloads, resumable uploads, filesystem operations, queues, zip/unzip, and media utilities with zero third-party dependencies.",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
   "types": "./lib/typescript/commonjs/src/index.d.ts",
@@ -105,7 +105,14 @@
     "mkdir",
     "ls",
     "blob-util-alternative",
-    "react-native-fs-alternative"
+    "react-native-fs-alternative",
+    "fs",
+    "zip",
+    "unzip",
+    "archive",
+    "storage",
+    "react-native-file-toolkit",
+    "fetch"
   ],
   "repository": {
     "type": "git",