@umituz/react-native-filesystem 1.5.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-filesystem",
-  "version": "1.5.0",
+  "version": "2.1.0",
   "description": "Domain-Driven Design filesystem utilities for React Native apps with build-time module loading and runtime file operations",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/services/FileSystemService.ts

@@ -3,15 +3,26 @@
  * Delegates to specialized services following SOLID principles
  */
 
-import { FileOperations } from "./FileOperations";
-import { FileManagement } from "./FileManagement";
-import { DirectoryOperations } from "./DirectoryOperations";
-import { FileInformation } from "./FileInformation";
-import { DownloadOperations } from "./DownloadOperations";
-import { CacheOperations } from "./CacheOperations";
-import { FilePathOperations } from "./FilePathOperations";
+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 { 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 {
+  FileEncoding,
+  DirectoryType,
+  FileOperationResult,
+} from "../../domain/entities/File";
 
 /**
  * FileSystem Service - Clean facade for all file operations
@@ -19,99 +30,126 @@ import type { FileEncoding, DirectoryType, FileOperationResult } from "../../dom
  */
 export class FileSystemService {
   // File Reading
-  static async readFile(uri: string, encoding: FileEncoding = "utf8"): Promise<string | null> {
-    return FileOperations.readFile(uri, encoding);
+  static async readFile(
+    uri: string,
+    encoding: FileEncoding = "utf8"
+  ): Promise<string | null> {
+    return readFile(uri, encoding);
   }
 
   static async readFileAsBase64(uri: string): Promise<string | null> {
-    return FileOperations.readFileAsBase64(uri);
+    return readFileAsBase64(uri);
   }
 
   // File Writing
-  static async writeFile(uri: string, content: string, encoding: FileEncoding = "utf8"): Promise<FileOperationResult> {
-    return FileOperations.writeFile(uri, content, encoding);
+  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 FileManagement.deleteFile(uri);
+    return deleteFile(uri);
   }
 
-  static async copyFile(sourceUri: string, destinationUri: string): Promise<FileOperationResult> {
-    return FileManagement.copyFile(sourceUri, destinationUri);
+  static async copyFile(
+    sourceUri: string,
+    destinationUri: string
+  ): Promise<FileOperationResult> {
+    return copyFile(sourceUri, destinationUri);
   }
 
-  static async moveFile(sourceUri: string, destinationUri: string): Promise<FileOperationResult> {
-    return FileManagement.moveFile(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 DirectoryOperations.createDirectory(uri);
+    return createDirectory(uri);
   }
 
   static async listDirectory(uri: string): Promise<string[]> {
-    return DirectoryOperations.listDirectory(uri);
+    return listDirectory(uri);
   }
 
   static getDirectoryPath(type: DirectoryType): string {
-    return DirectoryOperations.getDirectoryPath(type);
+    return getDirectoryPath(type);
   }
 
   static getDocumentDirectory(): string {
-    return DirectoryOperations.getDocumentDirectory();
+    return getDocumentDirectory();
   }
 
   static getCacheDirectory(): string {
-    return DirectoryOperations.getCacheDirectory();
+    return getCacheDirectory();
   }
 
   // File Information
   static async getFileInfo(uri: string) {
-    return FileInformation.getFileInfo(uri);
+    return getFileInfo(uri);
   }
 
   static async exists(uri: string): Promise<boolean> {
-    return FileInformation.exists(uri);
+    return fileExists(uri);
   }
 
   static async getFileSize(uri: string): Promise<number> {
-    return FileInformation.getFileSize(uri);
+    return getFileSize(uri);
   }
 
   // Downloads
-  static async downloadFile(url: string, destinationUri?: string): Promise<FileOperationResult> {
-    return DownloadOperations.downloadFile(url, destinationUri);
+  static async downloadFile(
+    url: string,
+    destinationUri?: string
+  ): Promise<FileOperationResult> {
+    return downloadFile(url, destinationUri);
   }
 
   // Cache Management
   static async clearCache(): Promise<boolean> {
-    return CacheOperations.clearCache();
+    return clearCache();
   }
 
   static async getDirectorySize(uri: string): Promise<number> {
-    return CacheOperations.getDirectorySize(uri);
+    return getDirectorySize(uri);
   }
 
   // File Path Generation
-  static generateFilePath(filename: string, directory: DirectoryType = "documentDirectory"): string {
-    return FilePathOperations.generateFilePath(filename, directory);
+  static generateFilePath(
+    filename: string,
+    directory: DirectoryType = "documentDirectory"
+  ): string {
+    return generateFilePath(filename, directory);
   }
 
   // Convenience methods
-  static async copyToCache(sourceUri: string, filename?: string): Promise<FileOperationResult> {
-    const destinationUri = FilePathOperations.generateUniqueFilePath(
-      filename || sourceUri.split("/").pop() || "file",
-      "cacheDirectory"
+  static async copyToCache(
+    sourceUri: string,
+    filename?: string
+  ): Promise<FileOperationResult> {
+    const cacheDir = getCacheDirectory();
+    const uniqueFilename = FileUtils.generateUniqueFilename(
+      filename || sourceUri.split("/").pop() || "file"
     );
-    return FileManagement.copyFile(sourceUri, destinationUri);
+    const destinationUri = FileUtils.joinPaths(cacheDir, uniqueFilename);
+    return copyFile(sourceUri, destinationUri);
   }
 
-  static async copyToDocuments(sourceUri: string, filename?: string): Promise<FileOperationResult> {
-    const destinationUri = FilePathOperations.generateUniqueFilePath(
-      filename || sourceUri.split("/").pop() || "file",
-      "documentDirectory"
+  static async copyToDocuments(
+    sourceUri: string,
+    filename?: string
+  ): Promise<FileOperationResult> {
+    const docDir = getDocumentDirectory();
+    const uniqueFilename = FileUtils.generateUniqueFilename(
+      filename || sourceUri.split("/").pop() || "file"
     );
-    return FileManagement.copyFile(sourceUri, destinationUri);
+    const destinationUri = FileUtils.joinPaths(docDir, uniqueFilename);
+    return copyFile(sourceUri, destinationUri);
   }
 }