@umituz/react-native-filesystem 2.1.10 → 2.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-filesystem",
-  "version": "2.1.10",
+  "version": "2.1.11",
   "description": "File operations and import/export functionality for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -14,6 +14,29 @@ export type {
 
 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";
+
+// Services - Directory Operations
+export {
+  getCacheDirectory,
+  getDocumentDirectory,
+  createDirectory,
+} from "./infrastructure/services/directory.service";
+
 // Services - File Operations
-export { downloadFile } from "./infrastructure/services/download.service";
 export { FileSystemService } from "./infrastructure/services/FileSystemService";
+export { fileExists, getFileInfo } from "./infrastructure/services/file-info.service";
+export { deleteFile } from "./infrastructure/services/file-manager.service";
+export { clearCache } from "./infrastructure/services/cache.service";

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

@@ -1,14 +1,22 @@
 /**
  * Download Service
- * Single Responsibility: Download files from URLs
+ * Single Responsibility: Download files from URLs with progress tracking
  */
 
-import { File, Paths } from "expo-file-system";
-import type { FileOperationResult } from "../../domain/entities/File";
+import { File, Paths, Directory } from "expo-file-system";
+import type { FileOperationResult, DownloadProgress } from "../../domain/entities/File";
 import { FileUtils } from "../../domain/entities/File";
 
+/** Progress callback type */
+export type DownloadProgressCallback = (progress: DownloadProgress) => void;
+
+/** Download with progress result */
+export interface DownloadWithProgressResult extends FileOperationResult {
+  fromCache?: boolean;
+}
+
 /**
- * Download file from URL
+ * Download file from URL (simple version without progress)
  */
 export async function downloadFile(
   url: string,
@@ -36,3 +44,164 @@ export async function downloadFile(
   }
 }
 
+/**
+ * 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;
+  }
+  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 cachedFile = new File(destUri);
+    if (cachedFile.exists && (cachedFile.size ?? 0) > 0) {
+      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}`);
+    }
+
+    const contentLength = response.headers.get("content-length");
+    const totalBytes = contentLength ? parseInt(contentLength, 10) : 0;
+
+    if (!response.body) {
+      // Fallback: no streaming support, use simple download
+      const result = await downloadFile(url, destUri);
+      return { ...result, fromCache: false };
+    }
+
+    // Stream download with progress
+    const reader = response.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let receivedBytes = 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,
+        });
+      }
+    }
+
+    // Combine chunks and write to file
+    const allChunks = new Uint8Array(receivedBytes);
+    let position = 0;
+    for (const chunk of chunks) {
+      allChunks.set(chunk, position);
+      position += chunk.length;
+    }
+
+    // Write bytes to file
+    const file = new File(destUri);
+    file.write(allChunks);
+
+    return { success: true, uri: destUri, fromCache: false };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Download failed",
+    };
+  }
+}
+
+/**
+ * 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;
+  }
+}
+
+/**
+ * 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;
+  }
+}
+
+/**
+ * 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;
+  }
+}

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

@@ -1,73 +0,0 @@
-/**
- * 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/domain/entities/ModuleContext.ts

@@ -1,31 +0,0 @@
-/**
- * Module Context Entity
- * Domain layer types for build-time module loading
- *
- * DEPRECATED: These types are kept for backward compatibility only.
- * The module loading functionality is no longer actively used.
- */
-
-/**
- * RequireFunction interface for Webpack/Metro require.context
- * @deprecated No longer actively used
- */
-export interface RequireContext {
-  keys(): string[];
-  (id: string): any;
-  <T>(id: string): T;
-  resolve(id: string): string;
-  id: string;
-}
-
-/**
- * Collection of loaded modules
- * @deprecated No longer actively used
- */
-export type ModuleCollection = Record<string, any>;
-
-/**
- * Supported file extensions for module loading
- * @deprecated No longer actively used
- */
-export type FileExtension = '.json' | '.js' | '.ts' | '.tsx';

package/src/infrastructure/services/ImportExportService.ts

@@ -1,268 +0,0 @@
-/**
- * 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/presentation/hooks/useImportExport.ts

@@ -1,175 +0,0 @@
-/**
- * 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,
-  };
-};