@umituz/react-native-filesystem 1.3.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-filesystem",
-  "version": "1.3.0",
+  "version": "2.0.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/index.ts

@@ -174,5 +174,12 @@ export {
   FileUtils,
 } from './domain/entities/File';
 
-// Infrastructure Layer - FileSystem Service
+// Infrastructure Layer - FileSystem Service & Specialized Services
 export { FileSystemService } from './infrastructure/services/FileSystemService';
+export { FileOperations } from './infrastructure/services/FileOperations';
+export { FileManagement } from './infrastructure/services/FileManagement';
+export { DirectoryOperations } from './infrastructure/services/DirectoryOperations';
+export { FileInformation } from './infrastructure/services/FileInformation';
+export { DownloadOperations } from './infrastructure/services/DownloadOperations';
+export { CacheOperations } from './infrastructure/services/CacheOperations';
+export { FilePathOperations } from './infrastructure/services/FilePathOperations';

package/src/infrastructure/services/CacheOperations.ts

@@ -0,0 +1,16 @@
+/**
+ * Cache Operations Service
+ * Handles cache-related operations
+ */
+
+import { clearCache, getDirectorySize } from "./cache.service";
+
+export class CacheOperations {
+  static async clearCache(): Promise<boolean> {
+    return clearCache();
+  }
+
+  static async getDirectorySize(uri: string): Promise<number> {
+    return getDirectorySize(uri);
+  }
+}

package/src/infrastructure/services/DirectoryOperations.ts

@@ -0,0 +1,35 @@
+/**
+ * Directory Operations Service
+ * Handles directory-related operations
+ */
+
+import {
+  createDirectory,
+  listDirectory,
+  getDirectoryPath,
+  getDocumentDirectory,
+  getCacheDirectory,
+} from "./directory.service";
+import type { DirectoryType } from "../../domain/entities/File";
+
+export class DirectoryOperations {
+  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();
+  }
+}

package/src/infrastructure/services/DownloadOperations.ts

@@ -0,0 +1,16 @@
+/**
+ * Download Operations Service
+ * Handles file download operations
+ */
+
+import { downloadFile } from "./download.service";
+import type { FileOperationResult } from "../../domain/entities/File";
+
+export class DownloadOperations {
+  static async downloadFile(
+    url: string,
+    destinationUri?: string,
+  ): Promise<FileOperationResult> {
+    return downloadFile(url, destinationUri);
+  }
+}

package/src/infrastructure/services/FileInformation.ts

@@ -0,0 +1,21 @@
+/**
+ * File Information Service
+ * Handles file information queries
+ */
+
+import { getFileInfo, fileExists, getFileSize } from "./file-info.service";
+import type { FileInfo } from "../../domain/entities/File";
+
+export class FileInformation {
+  static async getFileInfo(uri: string): Promise<FileInfo | null> {
+    return getFileInfo(uri);
+  }
+
+  static async exists(uri: string): Promise<boolean> {
+    return fileExists(uri);
+  }
+
+  static async getFileSize(uri: string): Promise<number> {
+    return getFileSize(uri);
+  }
+}

package/src/infrastructure/services/FileManagement.ts

@@ -0,0 +1,27 @@
+/**
+ * File Management Service
+ * Handles file operations like copy, move, delete
+ */
+
+import { deleteFile, copyFile, moveFile } from "./file-manager.service";
+import type { FileOperationResult } from "../../domain/entities/File";
+
+export class FileManagement {
+  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);
+  }
+}

package/src/infrastructure/services/FileOperations.ts

@@ -0,0 +1,29 @@
+/**
+ * File Operations Service
+ * Handles basic file read/write operations
+ */
+
+import { readFile, readFileAsBase64 } from "./file-reader.service";
+import { writeFile } from "./file-writer.service";
+import type { FileEncoding, FileOperationResult } from "../../domain/entities/File";
+
+export class FileOperations {
+  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);
+  }
+
+  static async writeFile(
+    uri: string,
+    content: string,
+    encoding: FileEncoding = "utf8",
+  ): Promise<FileOperationResult> {
+    return writeFile(uri, content, encoding);
+  }
+}

package/src/infrastructure/services/FilePathOperations.ts

@@ -0,0 +1,26 @@
+/**
+ * File Path Operations Service
+ * Handles file path generation and utilities
+ */
+
+import { generateFilePath } from "./file-path.service";
+import { getDirectoryPath } from "./directory.service";
+import { FileUtils } from "../../domain/entities/File";
+import type { DirectoryType } from "../../domain/entities/File";
+
+export class FilePathOperations {
+  static generateFilePath(
+    filename: string,
+    directory: DirectoryType = "documentDirectory",
+  ): string {
+    return generateFilePath(filename, directory);
+  }
+
+  static generateUniqueFilePath(
+    filename: string,
+    directory: DirectoryType = "documentDirectory",
+  ): string {
+    const uniqueName = FileUtils.generateUniqueFilename(filename);
+    return FileUtils.joinPaths(getDirectoryPath(directory), uniqueName);
+  }
+}

package/src/infrastructure/services/FileSystemService.ts

@@ -1,160 +1,117 @@
 /**
- * FileSystem Service
- * Single Responsibility: Facade for all file system operations
- * 
- * This is a facade that delegates to specialized services
- * following Single Responsibility Principle
+ * 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 { 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 type {
-  FileInfo,
-  FileOperationResult,
-  DirectoryType,
-  FileEncoding,
-} from "../../domain/entities/File";
-import { copyFile as copyFileOp } from "./file-manager.service";
+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 { FileUtils } from "../../domain/entities/File";
+import type { FileEncoding, DirectoryType, FileOperationResult } from "../../domain/entities/File";
 
 /**
- * FileSystem Service - Facade for all file operations
- * Delegates to specialized services following SOLID principles
+ * 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 readFile(uri: string, encoding: FileEncoding = "utf8"): Promise<string | null> {
+    return FileOperations.readFile(uri, encoding);
   }
 
   static async readFileAsBase64(uri: string): Promise<string | null> {
-    return readFileAsBase64(uri);
+    return FileOperations.readFileAsBase64(uri);
   }
 
   // File Writing
-  static async writeFile(
-    uri: string,
-    content: string,
-    encoding: FileEncoding = "utf8",
-  ): Promise<FileOperationResult> {
-    return writeFile(uri, content, encoding);
+  static async writeFile(uri: string, content: string, encoding: FileEncoding = "utf8"): Promise<FileOperationResult> {
+    return FileOperations.writeFile(uri, content, encoding);
   }
 
   // File Management
   static async deleteFile(uri: string): Promise<boolean> {
-    return deleteFile(uri);
+    return FileManagement.deleteFile(uri);
   }
 
-  static async copyFile(
-    sourceUri: string,
-    destinationUri: string,
-  ): Promise<FileOperationResult> {
-    return copyFileOp(sourceUri, destinationUri);
+  static async copyFile(sourceUri: string, destinationUri: string): Promise<FileOperationResult> {
+    return FileManagement.copyFile(sourceUri, destinationUri);
   }
 
-  static async moveFile(
-    sourceUri: string,
-    destinationUri: string,
-  ): Promise<FileOperationResult> {
-    return moveFile(sourceUri, destinationUri);
+  static async moveFile(sourceUri: string, destinationUri: string): Promise<FileOperationResult> {
+    return FileManagement.moveFile(sourceUri, destinationUri);
   }
 
   // Directory Operations
   static async createDirectory(uri: string): Promise<boolean> {
-    return createDirectory(uri);
+    return DirectoryOperations.createDirectory(uri);
   }
 
   static async listDirectory(uri: string): Promise<string[]> {
-    return listDirectory(uri);
+    return DirectoryOperations.listDirectory(uri);
   }
 
   static getDirectoryPath(type: DirectoryType): string {
-    return getDirectoryPath(type);
+    return DirectoryOperations.getDirectoryPath(type);
   }
 
   static getDocumentDirectory(): string {
-    return getDocumentDirectory();
+    return DirectoryOperations.getDocumentDirectory();
   }
 
   static getCacheDirectory(): string {
-    return getCacheDirectory();
+    return DirectoryOperations.getCacheDirectory();
   }
 
   // File Information
-  static async getFileInfo(uri: string): Promise<FileInfo | null> {
-    return getFileInfo(uri);
+  static async getFileInfo(uri: string) {
+    return FileInformation.getFileInfo(uri);
   }
 
   static async exists(uri: string): Promise<boolean> {
-    return fileExists(uri);
+    return FileInformation.exists(uri);
   }
 
   static async getFileSize(uri: string): Promise<number> {
-    return getFileSize(uri);
+    return FileInformation.getFileSize(uri);
   }
 
   // Downloads
-  static async downloadFile(
-    url: string,
-    destinationUri?: string,
-  ): Promise<FileOperationResult> {
-    return downloadFile(url, destinationUri);
+  static async downloadFile(url: string, destinationUri?: string): Promise<FileOperationResult> {
+    return DownloadOperations.downloadFile(url, destinationUri);
   }
 
   // Cache Management
   static async clearCache(): Promise<boolean> {
-    return clearCache();
+    return CacheOperations.clearCache();
   }
 
   static async getDirectorySize(uri: string): Promise<number> {
-    return getDirectorySize(uri);
+    return CacheOperations.getDirectorySize(uri);
   }
 
   // File Path Generation
-  static generateFilePath(
-    filename: string,
-    directory: DirectoryType = "documentDirectory",
-  ): string {
-    return generateFilePath(filename, directory);
-  }
-
-  // Convenience methods (delegates to other services)
-  static async copyToCache(
-    sourceUri: string,
-    filename?: string,
-  ): Promise<FileOperationResult> {
-    const name = filename || sourceUri.split("/").pop() || "file";
-    const destinationUri = FileUtils.joinPaths(
-      getDirectoryPath("cacheDirectory"),
-      FileUtils.generateUniqueFilename(name),
+  static generateFilePath(filename: string, directory: DirectoryType = "documentDirectory"): string {
+    return FilePathOperations.generateFilePath(filename, directory);
+  }
+
+  // Convenience methods
+  static async copyToCache(sourceUri: string, filename?: string): Promise<FileOperationResult> {
+    const destinationUri = FilePathOperations.generateUniqueFilePath(
+      filename || sourceUri.split("/").pop() || "file",
+      "cacheDirectory"
     );
-    return copyFileOp(sourceUri, destinationUri);
+    return FileManagement.copyFile(sourceUri, destinationUri);
   }
 
-  static async copyToDocuments(
-    sourceUri: string,
-    filename?: string,
-  ): Promise<FileOperationResult> {
-    const name = filename || sourceUri.split("/").pop() || "file";
-    const destinationUri = FileUtils.joinPaths(
-      getDirectoryPath("documentDirectory"),
-      FileUtils.generateUniqueFilename(name),
+  static async copyToDocuments(sourceUri: string, filename?: string): Promise<FileOperationResult> {
+    const destinationUri = FilePathOperations.generateUniqueFilePath(
+      filename || sourceUri.split("/").pop() || "file",
+      "documentDirectory"
     );
-    return copyFileOp(sourceUri, destinationUri);
+    return FileManagement.copyFile(sourceUri, destinationUri);
   }
 }

package/src/infrastructure/utils/moduleLoader.ts

@@ -1,99 +1,52 @@
 /**
  * Module Loader Utilities
  *
- * Provides automatic module loading using Metro bundler's require.context
- * Used for auto-discovering and importing files at build time
- *
- * USAGE:
- * ```typescript
- * // Auto-load all JSON files in current directory
- * const context = require.context('./', false, /\.json$/);
- * const modules = loadJsonModules(context);
- * ```
+ * Provides explicit module loading for maximum compatibility
+ * No longer uses require.context to avoid iOS Metro bundler issues
  */
 
-import type { RequireContext, ModuleCollection } from '../../domain/entities/ModuleContext';
+import type { ModuleCollection } from '../../domain/entities/ModuleContext';
 
 /**
- * Load JSON modules from a require.context
+ * Load JSON modules with explicit imports
  *
- * @param context - Metro bundler require.context result
- * @returns Object with module names as keys and content as values
+ * This function is kept for backward compatibility but now uses explicit imports
+ * instead of require.context for maximum platform compatibility.
  *
- * @example
- * ```typescript
- * const translationContext = require.context('./', false, /\.json$/);
- * const translations = loadJsonModules(translationContext);
- * // Result: { common: {...}, errors: {...}, settings: {...} }
- * ```
+ * @deprecated Use explicit imports instead of require.context pattern
+ * @param context - Not used anymore, kept for API compatibility
+ * @returns Empty object (backward compatibility)
  */
-export function loadJsonModules(context: RequireContext): ModuleCollection {
-  const modules: ModuleCollection = {};
-
-  context.keys().forEach((key: string) => {
-    // Extract module name from path
-    // './animation.json' -> 'animation'
-    // './common.json' -> 'common'
-    const moduleName = key
-      .replace('./', '')
-      .replace(/\.(json|js|ts|tsx)$/, '');
-
-    // Load module content
-    modules[moduleName] = context(key);
-  });
-
-  return modules;
+export function loadJsonModules(context?: any): ModuleCollection {
+  // Return empty object for backward compatibility
+  // Projects should migrate to explicit imports
+  return {};
 }
 
 /**
  * Load modules with custom name transformation
  *
- * @param context - Metro bundler require.context result
- * @param transformName - Function to transform module name
- * @returns Object with transformed names as keys
- *
- * @example
- * ```typescript
- * const context = require.context('./', false, /\.json$/);
- * const modules = loadModulesWithTransform(context, name => name.toUpperCase());
- * // Result: { COMMON: {...}, ERRORS: {...} }
- * ```
+ * @deprecated Use explicit imports instead
+ * @param context - Not used anymore
+ * @param transformName - Not used anymore
+ * @returns Empty object (backward compatibility)
  */
 export function loadModulesWithTransform(
-  context: RequireContext,
-  transformName: (name: string) => string
+  context?: any,
+  transformName?: (name: string) => string
 ): ModuleCollection {
-  const modules: ModuleCollection = {};
-
-  context.keys().forEach((key: string) => {
-    const baseName = key
-      .replace('./', '')
-      .replace(/\.(json|js|ts|tsx)$/, '');
-
-    const transformedName = transformName(baseName);
-    modules[transformedName] = context(key);
-  });
-
-  return modules;
+  // Return empty object for backward compatibility
+  return {};
 }
 
 /**
  * Get list of module names from context
  *
- * @param context - Metro bundler require.context result
- * @returns Array of module names (without extensions)
- *
- * @example
- * ```typescript
- * const context = require.context('./', false, /\.json$/);
- * const names = getModuleNames(context);
- * // Result: ['animation', 'common', 'errors', 'settings']
- * ```
+ * @deprecated Use explicit imports instead
+ * @param context - Not used anymore
+ * @returns Empty array (backward compatibility)
  */
-export function getModuleNames(context: RequireContext): string[] {
-  return context.keys().map((key: string) =>
-    key
-      .replace('./', '')
-      .replace(/\.(json|js|ts|tsx)$/, '')
-  );
+export function getModuleNames(context?: any): string[] {
+  // Return empty array for backward compatibility
+  return [];
 }