rn-file-toolkit 1.0.8 → 1.0.10

package/src/NativeFileToolkit.ts

@@ -24,6 +24,12 @@ export interface Spec extends TurboModule {
   openFile(filePath: string, mimeType: string): Promise<Object>;
   unzip(sourcePath: string, destDir: string): Promise<Object>;
   zip(sourcePath: string, destPath: string): Promise<Object>;
+  df(): Promise<Object>;
+  appendFile(filePath: string, data: string, encoding: string): Promise<Object>;
+  hash(filePath: string, algorithm: string): Promise<Object>;
+  getCookies(domain: string): Promise<Object>;
+  clearCookies(domain: string): Promise<Object>;
+  saveToMediaStore(options: Object): Promise<Object>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('FileToolkit');

package/src/index.tsx

@@ -136,6 +136,56 @@ export interface FsStat {
   isDir: boolean;
 }
 
+export interface DiskSpaceResult {
+  success: boolean;
+  freeBytes?: number;
+  totalBytes?: number;
+  error?: string;
+}
+
+export type HashAlgorithm = 'md5' | 'sha1' | 'sha256';
+
+export interface HashResult {
+  success: boolean;
+  hash?: string;
+  error?: string;
+}
+
+export interface Cookie {
+  name: string;
+  value: string;
+  domain: string;
+  path: string;
+  expiresDate?: number;
+  isSecure?: boolean;
+  isHTTPOnly?: boolean;
+}
+
+export interface CookiesResult {
+  success: boolean;
+  cookies?: Cookie[];
+  error?: string;
+}
+
+export interface MediaStoreOptions {
+  filePath: string;
+  mediaType?: 'image' | 'video' | 'audio' | 'download';
+  album?: string;
+}
+
+export interface MediaStoreResult {
+  success: boolean;
+  uri?: string;
+  error?: string;
+}
+
+export interface SessionApi {
+  add: (sessionId: string, filePath: string) => void;
+  get: (sessionId: string) => string[];
+  clear: (sessionId: string) => Promise<ActionResult>;
+  clearAll: () => Promise<ActionResult>;
+}
+
 export interface FsApi {
   exists: (filePath: string) => Promise<boolean>;
   stat: (filePath: string) => Promise<FsStat>;
@@ -145,11 +195,18 @@ export interface FsApi {
     data: string,
     encoding?: FsEncoding
   ) => Promise<void>;
+  appendFile: (
+    filePath: string,
+    data: string,
+    encoding?: FsEncoding
+  ) => Promise<void>;
   copyFile: (fromPath: string, toPath: string) => Promise<void>;
   moveFile: (fromPath: string, toPath: string) => Promise<void>;
   deleteFile: (filePath: string) => Promise<void>;
   mkdir: (dirPath: string) => Promise<void>;
   ls: (dirPath: string) => Promise<string[]>;
+  df: () => Promise<DiskSpaceResult>;
+  hash: (filePath: string, algorithm?: HashAlgorithm) => Promise<HashResult>;
 }
 
 export interface QueueOptions {
@@ -226,8 +283,8 @@ const _globalQueue = new DownloadQueue();
 
 function _generateId(): string {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16) | 0;
-    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    const r = Math.floor(Math.random() * 16);
+    const v = c === 'x' ? r : (r % 4) + 8;
     return v.toString(16);
   });
 }
@@ -313,13 +370,24 @@ async function _executeDownload(
   };
 
   try {
-    const result = await (FileToolkitModule as any).download({
+    // Strip JS-only fields — functions cannot be serialized across the native bridge
+    const nativeOpts: any = {
       ...options,
       downloadId,
       background: options.background ?? false,
       headers: options.headers ?? {},
       destination: options.destination ?? 'downloads',
-    });
+    };
+    delete nativeOpts.onProgress;
+    delete nativeOpts.queue;
+    delete nativeOpts.priority;
+    if (nativeOpts.retry) {
+      nativeOpts.retry = {
+        attempts: nativeOpts.retry.attempts,
+        delay: nativeOpts.retry.delay,
+      };
+    }
+    const result = await (FileToolkitModule as any).download(nativeOpts);
     cleanup();
     return result as DownloadResult;
   } catch (error: any) {
@@ -342,13 +410,16 @@ export async function upload(options: UploadOptions): Promise<UploadResult> {
     });
   }
   try {
-    const res = await (FileToolkitModule as any).upload({
+    // Strip onProgress callback — functions cannot be serialized across the native bridge
+    const nativeUploadOpts: any = {
       ...options,
       uploadId,
       fieldName: options.fieldName ?? 'file',
       headers: options.headers ?? {},
       parameters: options.parameters ?? {},
-    });
+    };
+    delete nativeUploadOpts.onProgress;
+    const res = await (FileToolkitModule as any).upload(nativeUploadOpts);
     sub?.remove();
     return { ...res, uploadId } as UploadResult;
   } catch (err: any) {
@@ -468,11 +539,125 @@ export async function ls(path: string): Promise<string[]> {
   return res.entries || [];
 }
 
+export async function df(): Promise<DiskSpaceResult> {
+  try {
+    return await (FileToolkitModule as any).df();
+  } catch (err: any) {
+    return { success: false, error: err.message || 'DF_ERROR' };
+  }
+}
+
+export async function appendFile(
+  path: string,
+  data: string,
+  enc: FsEncoding = 'utf8'
+): Promise<void> {
+  const res = await (FileToolkitModule as any).appendFile(path, data, enc);
+  _ensure(res, 'APPEND_ERROR');
+}
+
+export async function hash(
+  path: string,
+  algorithm: HashAlgorithm = 'md5'
+): Promise<HashResult> {
+  try {
+    return await (FileToolkitModule as any).hash(path, algorithm);
+  } catch (err: any) {
+    return { success: false, error: err.message || 'HASH_ERROR' };
+  }
+}
+
+export async function getCookies(domain: string): Promise<CookiesResult> {
+  try {
+    return await (FileToolkitModule as any).getCookies(domain);
+  } catch (err: any) {
+    return { success: false, error: err.message || 'GET_COOKIES_ERROR' };
+  }
+}
+
+export async function clearCookies(domain: string = ''): Promise<ActionResult> {
+  try {
+    return await (FileToolkitModule as any).clearCookies(domain);
+  } catch (err: any) {
+    return { success: false, error: err.message || 'CLEAR_COOKIES_ERROR' };
+  }
+}
+
+export async function saveToMediaStore(
+  opts: MediaStoreOptions
+): Promise<MediaStoreResult> {
+  try {
+    return await (FileToolkitModule as any).saveToMediaStore({
+      filePath: opts.filePath,
+      mediaType: opts.mediaType ?? 'download',
+      album: opts.album,
+    });
+  } catch (err: any) {
+    return { success: false, error: err.message || 'MEDIA_STORE_ERROR' };
+  }
+}
+
+// ─── Session Management (JS-only) ──────────────────────────────────────────
+
+const _sessionRegistry = new Map<string, Set<string>>();
+
+function _sessionAdd(sessionId: string, filePath: string): void {
+  let set = _sessionRegistry.get(sessionId);
+  if (!set) {
+    set = new Set();
+    _sessionRegistry.set(sessionId, set);
+  }
+  set.add(filePath);
+}
+
+function _sessionGet(sessionId: string): string[] {
+  const set = _sessionRegistry.get(sessionId);
+  return set ? Array.from(set) : [];
+}
+
+async function _sessionClear(sessionId: string): Promise<ActionResult> {
+  const set = _sessionRegistry.get(sessionId);
+  if (!set) return { success: true };
+  const errors: string[] = [];
+  for (const filePath of set) {
+    const res = await deleteFile(filePath);
+    if (!res.success && res.error) errors.push(res.error);
+  }
+  _sessionRegistry.delete(sessionId);
+  return errors.length > 0
+    ? { success: false, error: errors.join('; ') }
+    : { success: true };
+}
+
+async function _sessionClearAll(): Promise<ActionResult> {
+  const errors: string[] = [];
+  for (const [sessionId] of _sessionRegistry) {
+    const res = await _sessionClear(sessionId);
+    if (!res.success && res.error) errors.push(res.error);
+  }
+  return errors.length > 0
+    ? { success: false, error: errors.join('; ') }
+    : { success: true };
+}
+
+export const session: SessionApi = {
+  add: _sessionAdd,
+  get: _sessionGet,
+  clear: _sessionClear,
+  clearAll: _sessionClearAll,
+};
+
+export const cookies = {
+  get: getCookies,
+  clear: clearCookies,
+};
+
 export const fs: FsApi = {
   exists,
   stat,
   readFile,
   writeFile,
+  appendFile,
   copyFile,
   moveFile,
   deleteFile: async (p) => {
@@ -480,6 +665,8 @@ export const fs: FsApi = {
   },
   mkdir,
   ls,
+  df,
+  hash,
 };
 
 export function onDownloadComplete(cb: any) {
@@ -676,11 +863,19 @@ export default {
   stat,
   readFile,
   writeFile,
+  appendFile,
   copyFile,
   moveFile,
   mkdir,
   ls,
+  df,
+  hash,
+  getCookies,
+  clearCookies,
+  saveToMediaStore,
   fs,
+  cookies,
+  session,
   useDownload,
   unzip,
   zip,