@umituz/react-native-filesystem 2.1.16 → 2.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-filesystem",
-  "version": "2.1.16",
+  "version": "2.1.17",
   "description": "File operations and import/export functionality for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -36,10 +36,14 @@
   },
   "devDependencies": {
     "@types/react": "~19.1.10",
+    "@typescript-eslint/eslint-plugin": "^8.52.0",
+    "@typescript-eslint/parser": "^8.52.0",
+    "eslint": "^9.39.2",
     "expo-file-system": "^19.0.21",
     "react": "19.1.0",
     "react-native": "0.81.5",
-    "typescript": "~5.3.0"
+    "typescript": "~5.3.0",
+    "typescript-eslint": "^8.52.0"
   },
   "publishConfig": {
     "access": "public"

package/src/domain/constants/FileConstants.ts

@@ -0,0 +1,20 @@
+/**
+ * File Constants
+ * File-related constants for the filesystem package
+ */
+
+import type { FileEncoding } from '../types/FileTypes';
+
+/**
+ * File-related constants
+ */
+export const FILE_CONSTANTS = {
+  MAX_FILE_SIZE: 100 * 1024 * 1024, // 100 MB
+  ALLOWED_EXTENSIONS: ['.jpg', '.jpeg', '.png', '.pdf', '.txt', '.json', '.mp4', '.mp3'] as const,
+  DEFAULT_ENCODING: 'utf8' as FileEncoding,
+} as const;
+
+/**
+ * Allowed file extensions type
+ */
+export type AllowedExtension = typeof FILE_CONSTANTS.ALLOWED_EXTENSIONS[number];

package/src/domain/entities/File.ts

@@ -1,132 +1,20 @@
 /**
- * File Entity
- * Domain layer types and utilities for file operations
+ * File Entity - Module Index
+ * Domain layer exports for file operations
  */
 
-/**
- * File encoding types supported by expo-file-system
- */
-export type FileEncoding = 'utf8' | 'base64';
-
-/**
- * Directory types available in expo-file-system
- */
-export type DirectoryType = 'documentDirectory' | 'cacheDirectory';
-
-/**
- * Result of a file operation
- */
-export interface FileOperationResult {
-  success: boolean;
-  uri?: string;
-  error?: string;
-}
-
-/**
- * File information metadata
- */
-export interface FileInfo {
-  uri: string;
-  name?: string;
-  size: number;
-  exists: boolean;
-  isDirectory: boolean;
-  modificationTime?: number;
-}
-
-/**
- * Download progress information
- */
-export interface DownloadProgress {
-  totalBytesWritten: number;
-  totalBytesExpectedToWrite: number;
-}
-
-/**
- * File-related constants
- */
-export const FILE_CONSTANTS = {
-  MAX_FILE_SIZE: 100 * 1024 * 1024, // 100 MB
-  ALLOWED_EXTENSIONS: ['.jpg', '.jpeg', '.png', '.pdf', '.txt', '.json', '.mp4', '.mp3'],
-  DEFAULT_ENCODING: 'utf8' as FileEncoding,
-} as const;
-
-/**
- * File utility functions
- */
-export class FileUtils {
-  /**
-   * Format file size in bytes to human-readable format
-   */
-  static formatFileSize(bytes: number): string {
-    if (bytes === 0) return '0 Bytes';
-    const k = 1024;
-    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
-  }
-
-  /**
-   * Generate unique filename with timestamp
-   */
-  static generateUniqueFilename(filename: string): string {
-    const timestamp = Date.now();
-    const extension = filename.includes('.') ? filename.substring(filename.lastIndexOf('.')) : '';
-    const nameWithoutExt = filename.includes('.')
-      ? filename.substring(0, filename.lastIndexOf('.'))
-      : filename;
-    return `${nameWithoutExt}_${timestamp}${extension}`;
-  }
-
-  /**
-   * Sanitize filename by removing invalid characters
-   */
-  static sanitizeFilename(filename: string): string {
-    return filename.replace(/[^a-zA-Z0-9._-]/g, '_');
-  }
-
-  /**
-   * Join path segments
-   */
-  static joinPaths(...segments: string[]): string {
-    return segments
-      .map((segment, index) => {
-        if (index === 0) {
-          return segment.replace(/\/+$/, '');
-        }
-        return segment.replace(/^\/+/, '').replace(/\/+$/, '');
-      })
-      .filter(segment => segment.length > 0)
-      .join('/');
-  }
-
-  /**
-   * Get file extension from filename
-   */
-  static getFileExtension(filename: string): string {
-    const lastDot = filename.lastIndexOf('.');
-    return lastDot > 0 ? filename.substring(lastDot) : '';
-  }
-
-  /**
-   * Check if file extension is allowed
-   */
-  static isAllowedExtension(filename: string): boolean {
-    const extension = this.getFileExtension(filename).toLowerCase();
-    return FILE_CONSTANTS.ALLOWED_EXTENSIONS.includes(extension as typeof FILE_CONSTANTS.ALLOWED_EXTENSIONS[number]);
-  }
+// Types
+export type {
+  FileEncoding,
+  DirectoryType,
+  FileOperationResult,
+  FileInfo,
+  DownloadProgress,
+} from '../types/FileTypes';
 
-  /**
-   * Get filename from URI
-   */
-  static getFilenameFromUri(uri: string): string {
-    return uri.split('/').pop() || '';
-  }
+// Constants
+export { FILE_CONSTANTS } from '../constants/FileConstants';
+export type { AllowedExtension } from '../constants/FileConstants';
 
-  /**
-   * Validate file size
-   */
-  static isValidFileSize(size: number): boolean {
-    return size > 0 && size <= FILE_CONSTANTS.MAX_FILE_SIZE;
-  }
-}
+// Utils
+export { FileUtils } from '../utils/FileUtils';

package/src/domain/types/FileTypes.ts

@@ -0,0 +1,43 @@
+/**
+ * File Types
+ * Domain layer type definitions for file operations
+ */
+
+/**
+ * File encoding types supported by expo-file-system
+ */
+export type FileEncoding = 'utf8' | 'base64';
+
+/**
+ * Directory types available in expo-file-system
+ */
+export type DirectoryType = 'documentDirectory' | 'cacheDirectory';
+
+/**
+ * Result of a file operation
+ */
+export interface FileOperationResult {
+  success: boolean;
+  uri?: string;
+  error?: string;
+}
+
+/**
+ * File information metadata
+ */
+export interface FileInfo {
+  uri: string;
+  name?: string;
+  size: number;
+  exists: boolean;
+  isDirectory: boolean;
+  modificationTime?: number;
+}
+
+/**
+ * Download progress information
+ */
+export interface DownloadProgress {
+  totalBytesWritten: number;
+  totalBytesExpectedToWrite: number;
+}

package/src/domain/utils/FileUtils.ts

@@ -0,0 +1,86 @@
+/**
+ * File Utils
+ * File utility functions for common operations
+ */
+
+import { FILE_CONSTANTS, type AllowedExtension } from '../constants/FileConstants';
+
+/**
+ * File utility functions
+ */
+export class FileUtils {
+  /**
+   * Format file size in bytes to human-readable format
+   */
+  static formatFileSize(bytes: number): string {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+  }
+
+  /**
+   * Generate unique filename with timestamp
+   */
+  static generateUniqueFilename(filename: string): string {
+    const timestamp = Date.now();
+    const extension = filename.includes('.') ? filename.substring(filename.lastIndexOf('.')) : '';
+    const nameWithoutExt = filename.includes('.')
+      ? filename.substring(0, filename.lastIndexOf('.'))
+      : filename;
+    return `${nameWithoutExt}_${timestamp}${extension}`;
+  }
+
+  /**
+   * Sanitize filename by removing invalid characters
+   */
+  static sanitizeFilename(filename: string): string {
+    return filename.replace(/[^a-zA-Z0-9._-]/g, '_');
+  }
+
+  /**
+   * Join path segments
+   */
+  static joinPaths(...segments: string[]): string {
+    return segments
+      .map((segment, index) => {
+        if (index === 0) {
+          return segment.replace(/\/+$/, '');
+        }
+        return segment.replace(/^\/+/, '').replace(/\/+$/, '');
+      })
+      .filter(segment => segment.length > 0)
+      .join('/');
+  }
+
+  /**
+   * Get file extension from filename
+   */
+  static getFileExtension(filename: string): string {
+    const lastDot = filename.lastIndexOf('.');
+    return lastDot > 0 ? filename.substring(lastDot) : '';
+  }
+
+  /**
+   * Check if file extension is allowed
+   */
+  static isAllowedExtension(filename: string): boolean {
+    const extension = this.getFileExtension(filename).toLowerCase();
+    return FILE_CONSTANTS.ALLOWED_EXTENSIONS.includes(extension as AllowedExtension);
+  }
+
+  /**
+   * Get filename from URI
+   */
+  static getFilenameFromUri(uri: string): string {
+    return uri.split('/').pop() || '';
+  }
+
+  /**
+   * Validate file size
+   */
+  static isValidFileSize(size: number): boolean {
+    return size > 0 && size <= FILE_CONSTANTS.MAX_FILE_SIZE;
+  }
+}

package/src/index.ts

@@ -1,39 +1,17 @@
 /**
  * @umituz/react-native-filesystem
- * File operations for React Native apps
  */
 
 // Domain - Types and Utilities
-export type {
-  FileEncoding,
-  DirectoryType,
-  FileOperationResult,
-  FileInfo,
-  DownloadProgress,
-} from "./domain/entities/File";
-
+export type { FileEncoding, DirectoryType, FileOperationResult, FileInfo, DownloadProgress } from "./domain/entities/File";
 export { FILE_CONSTANTS, FileUtils } from "./domain/entities/File";
 
 // Services - Download Operations
-export type {
-  DownloadProgressCallback,
-  DownloadWithProgressResult,
-} from "./infrastructure/services/download.service";
-
-export {
-  downloadFile,
-  downloadFileWithProgress,
-  isUrlCached,
-  getCachedFileUri,
-  deleteCachedFile,
-} from "./infrastructure/services/download.service";
+export type { DownloadProgressCallback, DownloadWithProgressResult } from "./infrastructure/services/download.types";
+export { downloadFile, downloadFileWithProgress, isUrlCached, getCachedFileUri, deleteCachedFile } from "./infrastructure/services/download.service";
 
 // Services - Directory Operations
-export {
-  getCacheDirectory,
-  getDocumentDirectory,
-  createDirectory,
-} from "./infrastructure/services/directory.service";
+export { getCacheDirectory, getDocumentDirectory, createDirectory } from "./infrastructure/services/directory.service";
 
 // Services - File Operations
 export { FileSystemService } from "./infrastructure/services/FileSystemService";

package/src/infrastructure/services/FileSystemService.ts

@@ -1,155 +1,45 @@
 /**
  * FileSystem Service - Facade
- * Delegates to specialized services following SOLID principles
  */
 
 import { readFile, readFileAsBase64 } from "./file-reader.service";
 import { writeFile } from "./file-writer.service";
 import { deleteFile, copyFile, moveFile } from "./file-manager.service";
-import {
-  createDirectory,
-  listDirectory,
-  getDirectoryPath,
-  getDocumentDirectory,
-  getCacheDirectory,
-} from "./directory.service";
+import { createDirectory, listDirectory, getDirectoryPath, getDocumentDirectory, getCacheDirectory } from "./directory.service";
 import { getFileInfo, fileExists, getFileSize } from "./file-info.service";
 import { downloadFile } from "./download.service";
 import { clearCache, getDirectorySize } from "./cache.service";
 import { generateFilePath } from "./file-path.service";
 import { FileUtils } from "../../domain/entities/File";
-import type {
-  FileEncoding,
-  DirectoryType,
-  FileOperationResult,
-} from "../../domain/entities/File";
+import type { FileOperationResult } from "../../domain/entities/File";
 
-/**
- * FileSystem Service - Clean facade for all file operations
- * Delegates to specialized services following Single Responsibility Principle
- */
 export class FileSystemService {
-  // File Reading
-  static async readFile(
-    uri: string,
-    encoding: FileEncoding = "utf8"
-  ): Promise<string | null> {
-    return readFile(uri, encoding);
-  }
-
-  static async readFileAsBase64(uri: string): Promise<string | null> {
-    return readFileAsBase64(uri);
-  }
-
-  // File Writing
-  static async writeFile(
-    uri: string,
-    content: string,
-    encoding: FileEncoding = "utf8"
-  ): Promise<FileOperationResult> {
-    return writeFile(uri, content, encoding);
-  }
-
-  // File Management
-  static async deleteFile(uri: string): Promise<boolean> {
-    return deleteFile(uri);
-  }
-
-  static async copyFile(
-    sourceUri: string,
-    destinationUri: string
-  ): Promise<FileOperationResult> {
-    return copyFile(sourceUri, destinationUri);
-  }
-
-  static async moveFile(
-    sourceUri: string,
-    destinationUri: string
-  ): Promise<FileOperationResult> {
-    return moveFile(sourceUri, destinationUri);
-  }
-
-  // Directory Operations
-  static async createDirectory(uri: string): Promise<boolean> {
-    return createDirectory(uri);
-  }
-
-  static async listDirectory(uri: string): Promise<string[]> {
-    return listDirectory(uri);
-  }
-
-  static getDirectoryPath(type: DirectoryType): string {
-    return getDirectoryPath(type);
-  }
-
-  static getDocumentDirectory(): string {
-    return getDocumentDirectory();
-  }
-
-  static getCacheDirectory(): string {
-    return getCacheDirectory();
-  }
-
-  // File Information
-  static async getFileInfo(uri: string) {
-    return getFileInfo(uri);
-  }
-
-  static async exists(uri: string): Promise<boolean> {
-    return fileExists(uri);
-  }
-
-  static async getFileSize(uri: string): Promise<number> {
-    return getFileSize(uri);
-  }
-
-  // Downloads
-  static async downloadFile(
-    url: string,
-    destinationUri?: string
-  ): Promise<FileOperationResult> {
-    return downloadFile(url, destinationUri);
-  }
-
-  // Cache Management
-  static async clearCache(): Promise<boolean> {
-    return clearCache();
-  }
-
-  static async getDirectorySize(uri: string): Promise<number> {
-    return getDirectorySize(uri);
-  }
-
-  // File Path Generation
-  static generateFilePath(
-    filename: string,
-    directory: DirectoryType = "documentDirectory"
-  ): string {
-    return generateFilePath(filename, directory);
-  }
-
-  // Convenience methods
-  static async copyToCache(
-    sourceUri: string,
-    filename?: string
-  ): Promise<FileOperationResult> {
-    const cacheDir = getCacheDirectory();
-    const uniqueFilename = FileUtils.generateUniqueFilename(
-      filename || sourceUri.split("/").pop() || "file"
-    );
-    const destinationUri = FileUtils.joinPaths(cacheDir, uniqueFilename);
-    return copyFile(sourceUri, destinationUri);
-  }
-
-  static async copyToDocuments(
-    sourceUri: string,
-    filename?: string
-  ): Promise<FileOperationResult> {
-    const docDir = getDocumentDirectory();
-    const uniqueFilename = FileUtils.generateUniqueFilename(
-      filename || sourceUri.split("/").pop() || "file"
-    );
-    const destinationUri = FileUtils.joinPaths(docDir, uniqueFilename);
-    return copyFile(sourceUri, destinationUri);
+  static readFile = readFile;
+  static readFileAsBase64 = readFileAsBase64;
+  static writeFile = writeFile;
+  static deleteFile = deleteFile;
+  static copyFile = copyFile;
+  static moveFile = moveFile;
+  static createDirectory = createDirectory;
+  static listDirectory = listDirectory;
+  static getDirectoryPath = getDirectoryPath;
+  static getDocumentDirectory = getDocumentDirectory;
+  static getCacheDirectory = getCacheDirectory;
+  static getFileInfo = getFileInfo;
+  static exists = fileExists;
+  static getFileSize = getFileSize;
+  static downloadFile = downloadFile;
+  static clearCache = clearCache;
+  static getDirectorySize = getDirectorySize;
+  static generateFilePath = generateFilePath;
+
+  static async copyToCache(sourceUri: string, filename?: string): Promise<FileOperationResult> {
+    const dest = FileUtils.joinPaths(getCacheDirectory(), FileUtils.generateUniqueFilename(filename || sourceUri.split("/").pop() || "file"));
+    return copyFile(sourceUri, dest);
+  }
+
+  static async copyToDocuments(sourceUri: string, filename?: string): Promise<FileOperationResult> {
+    const dest = FileUtils.joinPaths(getDocumentDirectory(), FileUtils.generateUniqueFilename(filename || sourceUri.split("/").pop() || "file"));
+    return copyFile(sourceUri, dest);
   }
 }

package/src/infrastructure/services/cache.service.ts

@@ -21,7 +21,7 @@ export async function clearCache(): Promise<boolean> {
       files.map((file) => deleteFile(FileUtils.joinPaths(cacheDir, file))),
     );
     return true;
-  } catch (error) {
+  } catch {
     return false;
   }
 }
@@ -40,7 +40,7 @@ export async function getDirectorySize(uri: string): Promise<number> {
       }),
     );
     return sizes.reduce((total, size) => total + size, 0);
-  } catch (error) {
+  } catch {
     return 0;
   }
 }

package/src/infrastructure/services/directory.service.ts

@@ -14,7 +14,7 @@ export async function createDirectory(uri: string): Promise<boolean> {
     const dir = new Directory(uri);
     dir.create({ intermediates: true, idempotent: true });
     return true;
-  } catch (error) {
+  } catch {
     return false;
   }
 }
@@ -27,7 +27,7 @@ export async function listDirectory(uri: string): Promise<string[]> {
     const dir = new Directory(uri);
     const items = dir.list();
     return items.map((item) => item.uri);
-  } catch (error) {
+  } catch {
     return [];
   }
 }
@@ -45,7 +45,7 @@ export function getDirectoryPath(type: DirectoryType): string {
       default:
         return "";
     }
-  } catch (error) {
+  } catch {
     return "";
   }
 }

package/src/infrastructure/services/download.service.ts

@@ -1,207 +1,115 @@
 /**
  * Download Service
- * Single Responsibility: Download files from URLs with progress tracking
+ * Single Responsibility: Handle file download operations
  */
 
 import { File, Paths, Directory } from "expo-file-system";
-import type { FileOperationResult, DownloadProgress } from "../../domain/entities/File";
+import type { FileOperationResult } from "../../domain/entities/File";
 import { FileUtils } from "../../domain/entities/File";
+import type { DownloadProgressCallback, DownloadWithProgressResult } from "./download.types";
 
-/** Progress callback type */
-export type DownloadProgressCallback = (progress: DownloadProgress) => void;
+const hashUrl = (url: string): string => {
+  let hash = 0;
+  for (let i = 0; i < url.length; i++) hash = ((hash << 5) - hash + url.charCodeAt(i)) | 0;
+  return Math.abs(hash).toString(36);
+};
 
-/** Download with progress result */
-export interface DownloadWithProgressResult extends FileOperationResult {
-  fromCache?: boolean;
-}
+const getExt = (url: string): string => {
+  const ext = url.split("?")[0].split(".").pop()?.toLowerCase() || "mp4";
+  return ["mp4", "mov", "m4v", "webm", "jpg", "png", "pdf"].includes(ext) ? ext : "mp4";
+};
 
-/**
- * Download file from URL (simple version without progress)
- */
-export async function downloadFile(
-  url: string,
-  destinationUri?: string,
-): Promise<FileOperationResult> {
-  try {
-    let destination: File | typeof Paths.document;
-
-    if (destinationUri) {
-      destination = new File(destinationUri);
-    } else {
-      const filename = FileUtils.generateUniqueFilename("download");
-      destination = new File(Paths.document, filename);
-    }
+const getCacheUri = (url: string, dir: string): string => {
+  return FileUtils.joinPaths(dir, `cached_${hashUrl(url)}.${getExt(url)}`);
+};
 
-    const result = await File.downloadFileAsync(url, destination, {
-      idempotent: true,
-    });
-    return { success: true, uri: result.uri };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Download failed",
-    };
-  }
+interface DownloadError extends Error {
+  message: string;
 }
 
-/**
- * Generate hash from URL for cache filename
- */
-function hashUrl(url: string): string {
-  let hash = 0;
-  for (let i = 0; i < url.length; i++) {
-    const char = url.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
+export async function downloadFile(url: string, dest?: string): Promise<FileOperationResult> {
+  try {
+    const destination = dest
+      ? new File(dest)
+      : new File(Paths.document, FileUtils.generateUniqueFilename("download"));
+    const res = await File.downloadFileAsync(url, destination, { idempotent: true });
+    return { success: true, uri: res.uri };
+  } catch (error) {
+    const downloadError = error as DownloadError;
+    return { success: false, error: downloadError.message || "Unknown error" };
   }
-  return Math.abs(hash).toString(36);
 }
 
-/**
- * Get extension from URL
- */
-function getExtensionFromUrl(url: string): string {
-  const urlPath = url.split("?")[0];
-  const ext = urlPath.split(".").pop()?.toLowerCase() || "mp4";
-  const validExts = ["mp4", "mov", "m4v", "webm", "jpg", "png", "pdf"];
-  return validExts.includes(ext) ? ext : "mp4";
-}
-
-/**
- * Download file with progress tracking (uses expo/fetch for progress)
- * Falls back to simple download if progress not needed
- */
 export async function downloadFileWithProgress(
   url: string,
   cacheDir: string,
   onProgress?: DownloadProgressCallback,
 ): Promise<DownloadWithProgressResult> {
   try {
-    // Ensure cache directory exists
     const dir = new Directory(cacheDir);
     if (!dir.exists) {
       dir.create({ intermediates: true, idempotent: true });
     }
 
-    // Generate filename from URL hash
-    const hash = hashUrl(url);
-    const ext = getExtensionFromUrl(url);
-    const filename = `cached_${hash}.${ext}`;
-    const destUri = FileUtils.joinPaths(cacheDir, filename);
-
-    // Check if already cached
+    const destUri = getCacheUri(url, cacheDir);
     const cachedFile = new File(destUri);
-    if (cachedFile.exists && (cachedFile.size ?? 0) > 0) {
+    if (cachedFile.exists) {
       return { success: true, uri: destUri, fromCache: true };
     }
 
-    // Download using fetch with progress (expo/fetch)
     const response = await fetch(url);
-
     if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      throw new Error(`HTTP ${response.status}`);
     }
 
-    const contentLength = response.headers.get("content-length");
-    const totalBytes = contentLength ? parseInt(contentLength, 10) : 0;
-
+    const totalBytes = parseInt(response.headers.get("content-length") || "0", 10);
     if (!response.body) {
-      // Fallback: no streaming support, use simple download
-      const result = await downloadFile(url, destUri);
-      return { ...result, fromCache: false };
+      const downloadResult = await downloadFile(url, destUri);
+      return { ...downloadResult, fromCache: false };
     }
 
-    // Stream download with progress
     const reader = response.body.getReader();
     const chunks: Uint8Array[] = [];
-    let receivedBytes = 0;
+    let received = 0;
 
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
-
       chunks.push(value);
-      receivedBytes += value.length;
-
-      if (onProgress) {
-        onProgress({
-          totalBytesWritten: receivedBytes,
-          totalBytesExpectedToWrite: totalBytes || receivedBytes,
-        });
-      }
+      received += value.length;
+      onProgress?.({
+        totalBytesWritten: received,
+        totalBytesExpectedToWrite: totalBytes || received,
+      });
     }
 
-    // Combine chunks and write to file
-    const allChunks = new Uint8Array(receivedBytes);
-    let position = 0;
+    const all = new Uint8Array(received);
+    let pos = 0;
     for (const chunk of chunks) {
-      allChunks.set(chunk, position);
-      position += chunk.length;
+      all.set(chunk, pos);
+      pos += chunk.length;
     }
-
-    // Write bytes to file
-    const file = new File(destUri);
-    file.write(allChunks);
+    new File(destUri).write(all);
 
     return { success: true, uri: destUri, fromCache: false };
   } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Download failed",
-    };
+    const downloadError = error as DownloadError;
+    return { success: false, error: downloadError.message || "Unknown error" };
   }
 }
 
-/**
- * Check if URL is cached
- */
-export function isUrlCached(url: string, cacheDir: string): boolean {
-  try {
-    const hash = hashUrl(url);
-    const ext = getExtensionFromUrl(url);
-    const filename = `cached_${hash}.${ext}`;
-    const destUri = FileUtils.joinPaths(cacheDir, filename);
-    const file = new File(destUri);
-    return file.exists && (file.size ?? 0) > 0;
-  } catch {
-    return false;
-  }
-}
+export const isUrlCached = (url: string, dir: string): boolean => {
+  return new File(getCacheUri(url, dir)).exists;
+};
 
-/**
- * Get cached file URI if exists
- */
-export function getCachedFileUri(url: string, cacheDir: string): string | null {
-  try {
-    const hash = hashUrl(url);
-    const ext = getExtensionFromUrl(url);
-    const filename = `cached_${hash}.${ext}`;
-    const destUri = FileUtils.joinPaths(cacheDir, filename);
-    const file = new File(destUri);
-    if (file.exists && (file.size ?? 0) > 0) {
-      return destUri;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
+export const getCachedFileUri = (url: string, dir: string): string | null => {
+  return isUrlCached(url, dir) ? getCacheUri(url, dir) : null;
+};
 
-/**
- * Delete cached file
- */
-export function deleteCachedFile(url: string, cacheDir: string): boolean {
-  try {
-    const hash = hashUrl(url);
-    const ext = getExtensionFromUrl(url);
-    const filename = `cached_${hash}.${ext}`;
-    const destUri = FileUtils.joinPaths(cacheDir, filename);
-    const file = new File(destUri);
-    if (file.exists) {
-      file.delete();
-    }
-    return true;
-  } catch {
-    return false;
+export const deleteCachedFile = (url: string, dir: string): boolean => {
+  const file = new File(getCacheUri(url, dir));
+  if (file.exists) {
+    file.delete();
   }
-}
+  return true;
+};

package/src/infrastructure/services/download.types.ts

@@ -0,0 +1,7 @@
+import type { FileOperationResult, DownloadProgress } from "../../domain/entities/File";
+
+export type DownloadProgressCallback = (progress: DownloadProgress) => void;
+
+export interface DownloadWithProgressResult extends FileOperationResult {
+  fromCache?: boolean;
+}

package/src/infrastructure/services/encoding.service.ts

@@ -5,13 +5,15 @@
 
 import type { FileEncoding } from "../../domain/entities/File";
 
+/**
+ * Encoding type for Expo FileSystem
+ */
+export type ExpoEncodingType = FileEncoding;
+
 /**
  * Convert FileEncoding to Expo FileSystem encoding type
- * Legacy API uses EncodingType enum
  */
-export function getEncodingType(encoding: FileEncoding): any {
-  // Legacy API uses EncodingType enum
-  // Return as string for compatibility
+export function getEncodingType(encoding: FileEncoding): ExpoEncodingType {
   return encoding;
 }
 
@@ -21,4 +23,3 @@ export function getEncodingType(encoding: FileEncoding): any {
 export function isValidEncoding(encoding: string): encoding is FileEncoding {
   return encoding === "utf8" || encoding === "base64";
 }
-

package/src/infrastructure/services/file-info.service.ts

@@ -25,7 +25,7 @@ export async function getFileInfo(uri: string): Promise<FileInfo | null> {
       isDirectory: false,
       modificationTime: file.modificationTime || 0,
     };
-  } catch (error) {
+  } catch {
     return null;
   }
 }
@@ -37,7 +37,7 @@ export async function fileExists(uri: string): Promise<boolean> {
   try {
     const file = new File(uri);
     return file.exists;
-  } catch (error) {
+  } catch {
     return false;
   }
 }

package/src/infrastructure/services/file-manager.service.ts

@@ -34,7 +34,7 @@ export async function deleteFile(uri: string): Promise<boolean> {
     }
 
     return false;
-  } catch (error) {
+  } catch {
     return false;
   }
 }

package/src/infrastructure/services/file-reader.service.ts

@@ -5,7 +5,7 @@
 
 import { File } from "expo-file-system";
 import type { FileEncoding } from "../../domain/entities/File";
-
+import { blobToBase64 } from "../utils/blob.utils";
 
 /**
  * Read file as string with encoding
@@ -26,7 +26,7 @@ export async function readFile(
           }
           return await response.text();
         }
-      } catch (fetchError) {
+      } catch {
         // Fall through to FileSystem API
       }
     }
@@ -39,33 +39,14 @@ export async function readFile(
     }
     const content = await file.text();
     return content;
-  } catch (error) {
+  } catch {
     return null;
   }
 }
 
-/**
- * Convert blob to base64 string
- */
-function blobToBase64(blob: Blob): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onloadend = () => {
-      const result = reader.result as string;
-      // Remove data URL prefix if present
-      const base64 = result.includes(",") ? result.split(",")[1] : result;
-      resolve(base64);
-    };
-    reader.onerror = reject;
-    reader.readAsDataURL(blob);
-  });
-}
-
 /**
  * Read file as base64 string
  */
 export async function readFileAsBase64(uri: string): Promise<string | null> {
   return readFile(uri, "base64");
 }
-
-

package/src/infrastructure/services/file-writer.service.ts

@@ -5,7 +5,7 @@
 
 import { File } from "expo-file-system";
 import type { FileEncoding, FileOperationResult } from "../../domain/entities/File";
-import { getEncodingType } from "./encoding.service";
+import { getEncodingType, type ExpoEncodingType } from "./encoding.service";
 
 /**
  * Write string to file
@@ -19,14 +19,14 @@ export async function writeFile(
     const encodingType = getEncodingType(encoding);
     const file = new File(uri);
     file.write(content, {
-      encoding: encodingType as any,
+      encoding: encodingType as ExpoEncodingType,
     });
     return { success: true, uri };
   } catch (error) {
+    const writeError = error as Error;
     return {
       success: false,
-      error: error instanceof Error ? error.message : "Unknown error",
+      error: writeError.message || "Unknown error",
     };
   }
 }
-

package/src/infrastructure/utils/blob.utils.ts

@@ -0,0 +1,21 @@
+/**
+ * Blob Utils
+ * Blob utility functions for file operations
+ */
+
+/**
+ * Convert blob to base64 string
+ */
+export function blobToBase64(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      const result = reader.result as string;
+      // Remove data URL prefix if present
+      const base64 = result.includes(",") ? result.split(",")[1] : result;
+      resolve(base64);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}