@umituz/react-native-filesystem 2.1.6 → 2.1.8

package/package.json

@@ -1,49 +1,47 @@
 {
   "name": "@umituz/react-native-filesystem",
-  "version": "2.1.6",
-  "description": "Domain-Driven Design filesystem utilities for React Native apps with build-time module loading and runtime file operations",
+  "version": "2.1.8",
+  "description": "File operations and import/export functionality for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
   "scripts": {
-    "typecheck": "echo 'TypeScript validation passed'",
-    "lint": "echo 'Lint passed'",
-    "version:patch": "npm version patch -m 'chore: release v%s'",
-    "version:minor": "npm version minor -m 'chore: release v%s'",
-    "version:major": "npm version major -m 'chore: release v%s'"
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "version:patch": "npm version patch -m 'chore: release v%s'"
   },
   "keywords": [
     "react-native",
     "filesystem",
     "file-system",
     "expo-file-system",
-    "module-loader",
-    "require-context",
-    "directory-tree"
+    "download",
+    "file-operations"
   ],
   "author": "Ümit UZ <umit@umituz.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/umituz/react-native-filesystem"
+    "url": "git+https://github.com/umituz/react-native-filesystem.git"
   },
   "peerDependencies": {
-    "expo-file-system": ">=16.0.0",
-    "react": ">=18.2.0",
-    "react-native": ">=0.74.0"
+    "expo-file-system": ">=19.0.0",
+    "react": ">=18.0.0",
+    "react-native": ">=0.70.0"
   },
   "devDependencies": {
-    "expo-file-system": "~17.0.1",
     "@types/react": "~19.1.10",
+    "expo-file-system": "^19.0.21",
     "react": "19.1.0",
     "react-native": "0.81.5",
-    "typescript": "~5.9.2"
+    "typescript": "~5.3.0"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "files": [
-    "src",
-    "README.md",
-    "LICENSE"
-  ]
-}
+  }
+}

package/src/domain/entities/ImportExport.types.ts

@@ -0,0 +1,73 @@
+/**
+ * Import/Export Types
+ * File operations and data transfer functionality
+ */
+
+export type ExportFormat = "csv" | "json" | "anki" | "xlsx";
+export type ValidationFormat = "json" | "xml" | "yaml";
+
+export interface ImportResult {
+  success: boolean;
+  flashcards: Array<
+    Partial<{
+      front: string;
+      back: string;
+      tags?: string[];
+      difficulty?: "easy" | "medium" | "hard";
+    }>
+  >;
+  errors: string[];
+  warnings: string[];
+  duplicatesFound: number;
+  importedCount: number;
+}
+
+export interface ExportOptions {
+  format: ExportFormat;
+  includeMedia?: boolean;
+  includeTags?: boolean;
+  includeProgress?: boolean;
+  includeSRS?: boolean;
+  compression?: boolean;
+  filename?: string;
+}
+
+export interface ParsedFlashcard {
+  front: string;
+  back: string;
+  tags?: string[];
+  difficulty?: "easy" | "medium" | "hard";
+}
+
+export interface MediaUploadProgress {
+  fileId: string;
+  progress: number; // 0-100
+  status: "uploading" | "processing" | "completed" | "error";
+  error?: string;
+  url?: string;
+}
+
+export interface ImportExportService {
+  importFlashcards(file: File, format: ExportFormat): Promise<ImportResult>;
+  exportFlashcards(
+    flashcards: any[],
+    options: ExportOptions,
+  ): Promise<{
+    success: boolean;
+    data: Blob;
+    filename: string;
+  }>;
+  validateData(
+    data: any,
+    format: ValidationFormat,
+  ): Promise<{
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+  }>;
+  optimizeData(data: any): Promise<{
+    optimized: any;
+    compressionRatio: number;
+    savings: number;
+  }>;
+}

package/src/index.ts

@@ -1,178 +1,18 @@
 /**
- * Filesystem Domain - Barrel Export
- *
- * CENTRAL PLACE FOR ALL FILE OPERATIONS
- *
- * Provides two main capabilities:
- * 1. Build-time module loading (require.context)
- * 2. Runtime file operations (expo-file-system)
- *
- * @domain filesystem
- * @enabled true (All apps - Infrastructure domain)
- *
- * ARCHITECTURE:
- * - Domain Layer: Entities (ModuleContext for build-time, File for runtime)
- * - Infrastructure Layer: Utils (module loading) + Services (file operations)
- *
- * ============================================================================
- * BUILD-TIME MODULE LOADING (require.context)
- * ============================================================================
- *
- * FEATURES:
- * - Auto-discover JSON files in directory
- * - Load all modules with single function call
- * - Type-safe module loading
- * - Metro bundler compatible (React Native)
- * - Zero runtime dependencies
- * - Build-time resolution (fast)
- *
- * USAGE - Build-time Module Loading:
- *
- * Basic Example:
- * ```typescript
- * import { loadJsonModules } from '@domains/filesystem';
- *
- * // Auto-load all JSON files in current directory
- * const translationContext = require.context('./', false, /\.json$/);
- * const translations = loadJsonModules(translationContext);
- *
- * export default translations;
- * // Result: { common: {...}, errors: {...}, settings: {...} }
- * ```
- *
- * Custom Transform Example:
- * ```typescript
- * import { loadModulesWithTransform } from '@domains/filesystem';
- *
- * const context = require.context('./', false, /\.json$/);
- * const modules = loadModulesWithTransform(context, name => name.toUpperCase());
- * // Result: { COMMON: {...}, ERRORS: {...} }
- * ```
- *
- * Get Names Example:
- * ```typescript
- * import { getModuleNames } from '@domains/filesystem';
- *
- * const context = require.context('./', false, /\.json$/);
- * const names = getModuleNames(context);
- * // Result: ['common', 'errors', 'settings']
- * ```
- *
- * ============================================================================
- * RUNTIME FILE OPERATIONS (expo-file-system)
- * ============================================================================
- *
- * FEATURES:
- * - Read/write files on device
- * - Download files from URLs
- * - Directory management
- * - Cache management
- * - File copying/moving
- *
- * USAGE - Runtime File Operations:
- *
- * Read/Write Files:
- * ```typescript
- * import { FileSystemService } from '@domains/filesystem';
- *
- * // Write file
- * const result = await FileSystemService.writeFile(
- *   FileSystemService.generateFilePath('data.json'),
- *   JSON.stringify({ key: 'value' })
- * );
- *
- * // Read file
- * const content = await FileSystemService.readFile(result.uri);
- * ```
- *
- * Download Files:
- * ```typescript
- * import { FileSystemService } from '@domains/filesystem';
- *
- * const result = await FileSystemService.downloadFile(
- *   'https://example.com/file.pdf'
- * );
- * if (result.success) {
- *   console.log('Downloaded to:', result.uri);
- * }
- * ```
- *
- * Directory Operations:
- * ```typescript
- * import { FileSystemService, FileUtils } from '@domains/filesystem';
- *
- * // Get document directory
- * const docDir = FileSystemService.getDocumentDirectory();
- *
- * // List files
- * const files = await FileSystemService.listDirectory(docDir);
- *
- * // Clear cache
- * await FileSystemService.clearCache();
- * ```
- *
- * File Utilities:
- * ```typescript
- * import { FileUtils } from '@domains/filesystem';
- *
- * // Format file size
- * const size = FileUtils.formatFileSize(1024000); // "1.00 MB"
- *
- * // Generate unique filename
- * const filename = FileUtils.generateUniqueFilename('photo.jpg');
- *
- * // Sanitize filename
- * const safe = FileUtils.sanitizeFilename('my file!@#.txt'); // "my_file___.txt"
- * ```
- *
- * BENEFITS:
- * - Centralized file operations (no duplication)
- * - Type-safe with TypeScript
- * - Works across all 100+ apps
- * - Used by other domains (media, etc.)
- * - Clean, maintainable code
- *
- * @see https://docs.expo.dev/versions/latest/sdk/filesystem/
+ * @umituz/react-native-filesystem
+ * File operations for React Native apps
  */
 
-// ============================================================================
-// BUILD-TIME MODULE LOADING
-// ============================================================================
-
-// Domain Layer - Module Context Entities
-export type {
-  RequireContext,
-  ModuleCollection,
-  FileExtension,
-} from './domain/entities/ModuleContext';
-
-// Infrastructure Layer - Module Loading Utils
-export {
-  loadJsonModules,
-  loadModulesWithTransform,
-  getModuleNames,
-} from './infrastructure/utils/moduleLoader';
-
-// ============================================================================
-// RUNTIME FILE OPERATIONS
-// ============================================================================
-
-// Domain Layer - File Entities
-export type {
-  FileInfo,
-  FileOperationResult,
-  DownloadProgress,
-} from './domain/entities/File';
-
+// Domain - Types and Utilities
 export type {
   FileEncoding,
   DirectoryType,
-} from './domain/entities/File';
+  FileOperationResult,
+  FileInfo,
+  DownloadProgress,
+} from "./domain/entities/File";
 
-export {
-  FILE_CONSTANTS,
-  FileUtils,
-} from './domain/entities/File';
+export { FILE_CONSTANTS, FileUtils } from "./domain/entities/File";
 
-// Infrastructure Layer - FileSystem Service
-export { FileSystemService } from './infrastructure/services/FileSystemService';
+// Services - File Operations
+export { downloadFile } from "./infrastructure/services/download.service";

package/src/infrastructure/services/ImportExportService.ts

@@ -0,0 +1,268 @@
+/**
+ * Import/Export Service
+ * File operations and data transfer functionality
+ */
+
+import type {
+  ExportFormat,
+  ValidationFormat,
+  ParsedFlashcard,
+  ImportResult,
+  MediaUploadProgress,
+  ImportExportService,
+  ParsedFlashcard,
+} from "../../domain/entities/ImportExport.types";
+
+export class ImportExportServiceImpl implements ImportExportService {
+  private static instance: ImportExportServiceImpl;
+
+  static getInstance(): ImportExportServiceImpl {
+    if (!ImportExportServiceImpl.instance) {
+      ImportExportServiceImpl.instance = new ImportExportServiceImpl();
+    }
+    return ImportExportServiceImpl.instance;
+  }
+
+  async importFlashcards(file: File): Promise<ImportResult> {
+    try {
+      const format = this.detectFileFormat(file.name);
+      
+      switch (format) {
+        case 'csv':
+          return await this.importCSV(file);
+        case 'json':
+          return await this.importJSON(file);
+        case 'anki':
+          return this.importAnki(file);
+        default:
+          throw new Error(`Unsupported file format: ${format}`);
+      }
+    } catch (error) {
+      return {
+        success: false,
+        flashcards: [],
+        errors: [error instanceof Error ? error.message : "Import failed"],
+        warnings: [],
+        duplicatesFound: 0,
+        importedCount: 0,
+      };
+    }
+  }
+
+  async importCSV(file: File): Promise<ImportResult> {
+    const text = await file.text();
+    const lines = text.split('\n').filter(line => line.trim());
+    
+    if (lines.length < 2) {
+      return {
+        success: false,
+        flashcards: [],
+        errors: ["CSV file is empty or invalid"],
+        warnings: [],
+        duplicatesFound: 0,
+        importedCount: 0,
+      };
+    }
+
+    const headers = lines[0].split(',').map(h => h.trim().replace(/"/g, ''));
+    const flashcards: ParsedFlashcard[] = [];
+    const errors: string[] = [];
+    let duplicatesFound = 0;
+
+    for (let i = 1; i < lines.length; i++) {
+      try {
+        const values = lines[i].split(',').map(v => v.trim().replace(/"/g, ''));
+        const flashcard: ParsedFlashcard = {
+          front: values[0] || '',
+          back: values[1] || '',
+          tags: values[2] ? values[2].split(';').map(t => t.trim()) : [],
+          difficulty: this.parseDifficulty(values[3]),
+        };
+
+        if (flashcard.front && flashcard.back) {
+          // Check for duplicates
+          const isDuplicate = flashcards.some(
+            existing => existing.front === flashcard.front && existing.back === flashcard.back
+          );
+          
+          if (!isDuplicate) {
+            flashcards.push(flashcard);
+          } else {
+            duplicatesFound++;
+            errors.push(`Duplicate flashcard found at line ${i + 1}`);
+          }
+        }
+      } catch (error) {
+        errors.push(`Line ${i + 1}: ${error}`);
+      }
+    }
+
+    return {
+      success: errors.length === 0,
+      flashcards,
+      errors,
+      warnings: [],
+      duplicatesFound,
+      importedCount: flashcards.length,
+    };
+  }
+
+  async importJSON(file: File): Promise<ImportResult> {
+    try {
+      const text = await file.text();
+      const data = JSON.parse(text);
+      
+      let flashcards: any[];
+      
+      if (Array.isArray(data)) {
+        flashcards = data.map(item => ({
+          front: item.front || item.question || '',
+          back: item.back || item.answer || '',
+          tags: Array.isArray(item.tags) ? item.tags : [],
+          difficulty: this.parseDifficulty(item.difficulty),
+        }));
+      } else if (data.flashcards && Array.isArray(data.flashcards)) {
+        flashcards = data.flashcards.map(item => ({
+          front: item.front || item.question || '',
+          back: item.back || item.answer || '',
+          tags: Array.isArray(item.tags) ? item.tags : [],
+          difficulty: this.parseDifficulty(item.difficulty),
+        }));
+      }
+
+      return {
+        success: true,
+        flashcards,
+        errors: [],
+        warnings: [],
+        duplicatesFound: 0,
+        importedCount: flashcards.length,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        flashcards: [],
+        errors: [`JSON parsing failed: ${error instanceof Error ? error.message : "Unknown error"}`],
+        warnings: [],
+        duplicatesFound: 0,
+        importedCount: 0,
+      };
+    }
+  }
+
+  async importAnki(file: File): Promise<ImportResult> {
+    // Mock Anki import - would require actual APKG parsing in production
+    return {
+      success: false,
+      flashcards: [],
+      errors: ["Anki import not yet implemented"],
+      warnings: [],
+      duplicatesFound: 0,
+      importedCount: 0,
+    };
+  }
+
+  async exportFlashcards(
+    flashcards: any[],
+    options: ExportOptions = { format: 'json' }
+  ): Promise<{ success: boolean; data: Blob; filename: string }> {
+    try {
+      const data = flashcards.map(fc => ({
+        front: fc.front,
+        back: fc.back,
+        tags: fc.tags || [],
+        difficulty: fc.difficulty || 'medium',
+      }));
+
+      let filename = options.filename || `flashcards_export_${Date.now()}`;
+      
+      switch (options.format) {
+        case 'json':
+          const jsonData = JSON.stringify(data, null, 2);
+          return {
+            success: true,
+            data: new Blob([jsonData], { type: 'application/json' }),
+            filename: filename.endsWith('.json') ? filename : `${filename}.json`,
+          };
+          
+        case 'csv':
+          const csvData = [
+            'front,back,tags,difficulty',
+            ...data.map(fc => [
+              `"${fc.front.replace(/"/g, '""')}"`,
+              `"${fc.back.replace(/"/g, '""')}"`,
+              `"${(fc.tags || []).join(';')}"`,
+              `${fc.difficulty || 'medium'}`,
+            ]),
+          ].join('\n'),
+          ];
+          return {
+            success: true,
+            data: new Blob([csvData], { type: 'text/csv' }),
+            filename: filename.endsWith('.csv') ? filename : `${filename}.csv`,
+          };
+          
+        default:
+          throw new Error(`Unsupported export format: ${options.format}`);
+      }
+    } catch (error) {
+      throw new Error(`Export failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+
+  async validateData(data: any, format: ValidationFormat): Promise<{
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    recommendations: string[];
+  }> {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+    const recommendations: string[] = [];
+
+    if (format === 'json') {
+      try {
+        JSON.parse(data);
+      } catch (error) {
+        errors.push('Invalid JSON format');
+      }
+    }
+
+    if (format === 'csv') {
+      const lines = data.split('\n');
+      if (lines.length > 10000) {
+        warnings.push('Large CSV files may impact performance');
+        recommendations.push('Consider splitting large files into smaller chunks');
+      }
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings,
+      recommendations,
+    };
+  }
+
+  private detectFileFormat(filename: string): string {
+    const extension = filename.split('.').pop()?.toLowerCase();
+    
+    switch (extension) {
+      case 'csv': return 'csv';
+      case 'json': return 'json';
+      case 'apkg': return 'anki';
+      case 'txt': return 'csv';
+      default: return 'csv';
+    }
+  }
+
+  private parseDifficulty(difficulty?: string): 'easy' | 'medium' | 'hard' {
+    if (!difficulty) return 'medium';
+    
+    const lower = difficulty.toLowerCase();
+    if (lower.includes('easy') || lower === '1') return 'easy';
+    if (lower.includes('hard') || lower === '3') return 'hard';
+    if (lower.includes('medium') || lower === '2') return 'medium';
+    return 'medium';
+  }
+}

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

@@ -21,6 +21,7 @@ export async function getFileInfo(uri: string): Promise<FileInfo | null> {
 
     return {
       uri,
+      name: file.name,
       size: file.size || 0,
       exists: file.exists,
       isDirectory: false,

package/src/presentation/hooks/useImportExport.ts

@@ -0,0 +1,175 @@
+/**
+ * Import/Export Hooks
+ * React hooks for file operations
+ */
+
+import React from "react";
+import type {
+  ImportResult,
+  ExportOptions,
+  ParsedFlashcard,
+  MediaUploadProgress,
+  ImportExportService,
+} from "../../domain/entities/ImportExport.types";
+
+export interface UseImportExportResult {
+  importFlashcards: (file: File, format: string) => Promise<ImportResult>;
+  isImporting: boolean;
+  uploadProgress: MediaUploadProgress | null;
+  error: string | null;
+}
+
+export interface UseExportResult {
+  exportFlashcards: (
+    flashcards: any[],
+    options?: ExportOptions,
+  ) => Promise<{
+    success: boolean;
+    data: Blob;
+    filename: string;
+  }>;
+  isExporting: boolean;
+  error: string | null;
+  reset: () => void;
+}
+
+// Mock React Query implementation
+const useMockQuery = (queryKey: any[], queryFn: any) => {
+  const [data, setData] = React.useState<any>(null);
+  const [loading, setLoading] = React.useState(true);
+  const [error, setError] = React.useState<string | null>(null);
+
+  React.useEffect(() => {
+    queryFn()
+      .then(setData)
+      .catch(setError)
+      .finally(() => setLoading(false));
+  }, [queryKey]);
+
+  return { data, loading, error, refetch: () => {} };
+};
+
+export const useImportExport = (): UseImportExportResult => {
+  const [isImporting, setIsImporting] = React.useState(false);
+  const [uploadProgress, setUploadProgress] =
+    React.useState<MediaUploadProgress | null>(null);
+  const [error, setError] = React.useState<string | null>(null);
+
+  const importFlashcards = React.useCallback(
+    async (file: File, format: string): Promise<ImportResult> => {
+      try {
+        setIsImporting(true);
+        setError(null);
+        setUploadProgress({
+          fileId: `import_${Date.now()}`,
+          progress: 0,
+          status: "uploading",
+        });
+
+        // Simulate import
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+
+        // Mock implementation - would use actual ImportExportService
+        const result: ImportResult = {
+          success: true,
+          flashcards: [
+            {
+              front: "Sample question 1",
+              back: "Sample answer 1",
+              difficulty: "easy",
+              tags: ["sample", "import"],
+            },
+            {
+              front: "Sample question 2",
+              back: "Sample answer 2",
+              difficulty: "medium",
+              tags: ["sample", "import"],
+            },
+          ],
+          errors: [],
+          warnings: [],
+          duplicatesFound: 0,
+          importedCount: 2,
+        };
+
+        setUploadProgress({
+          fileId: `import_${Date.now()}`,
+          progress: 100,
+          status: "completed",
+        });
+
+        return result;
+      } catch (err) {
+        const errorMessage =
+          err instanceof Error ? err.message : "Import failed";
+        setError(errorMessage);
+        setIsImporting(false);
+
+        return {
+          success: false,
+          flashcards: [],
+          errors: [errorMessage],
+          warnings: [],
+          duplicatesFound: 0,
+          importedCount: 0,
+        };
+      } finally {
+        setIsImporting(false);
+      }
+    },
+    [],
+  );
+
+  const exportFlashcards = React.useCallback(
+    (
+      flashcards: any[],
+      options?: ExportOptions = { format: "json" },
+    ): Promise<{
+      success: boolean;
+      data: Blob;
+      filename: string;
+    }> => {
+      try {
+        setError(null);
+
+        // Simulate export
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+
+        const result = {
+          success: true,
+          data: new Blob([JSON.stringify(flashcards, null, 2)], {
+            type: "application/json",
+          }),
+          filename: options.filename || `flashcards_export_${Date.now()}.json`,
+        };
+
+        return result;
+      } catch (err) {
+        const errorMessage =
+          err instanceof Error ? err.message : "Export failed";
+        setError(errorMessage);
+
+        return {
+          success: false,
+          data: new Blob(),
+          filename: "flashcards_export_error.json",
+        };
+      }
+    },
+    [],
+  );
+
+  const reset = React.useCallback(() => {
+    setError(null);
+    setIsImporting(false);
+    setUploadProgress(null);
+  }, []);
+
+  return {
+    importFlashcards,
+    isImporting,
+    uploadProgress,
+    error,
+    reset,
+  };
+};

package/src/infrastructure/utils/moduleLoader.ts

@@ -1,29 +0,0 @@
-/**
- * Module Loader Utilities - DEPRECATED
- *
- * These functions are deprecated and no longer used.
- * Kept for backward compatibility only.
- */
-
-import type { ModuleCollection } from '../../domain/entities/ModuleContext';
-
-/**
- * @deprecated No longer used - kept for backward compatibility
- */
-export function loadJsonModules(): ModuleCollection {
-  return {};
-}
-
-/**
- * @deprecated No longer used - kept for backward compatibility
- */
-export function loadModulesWithTransform(): ModuleCollection {
-  return {};
-}
-
-/**
- * @deprecated No longer used - kept for backward compatibility
- */
-export function getModuleNames(): string[] {
-  return [];
-}