@umituz/react-native-design-system 2.8.6 → 2.8.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "description": "Universal design system for React Native apps - Consolidated package with atoms, molecules, organisms, theme, typography, responsive, safe area, exception, infinite scroll, UUID, image, timezone, offline, and onboarding utilities",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -23,6 +23,8 @@
     "./timezone": "./src/timezone/index.ts",
     "./offline": "./src/offline/index.ts",
     "./onboarding": "./src/onboarding/index.ts",
+    "./storage": "./src/storage/index.ts",
+    "./filesystem": "./src/filesystem/index.ts",
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -59,13 +61,12 @@
     "@expo/vector-icons": ">=15.0.0",
     "@react-native-community/datetimepicker": ">=8.0.0",
     "@react-native-community/slider": ">=4.0.0",
+    "@react-native-async-storage/async-storage": ">=1.18.0",
     "@react-navigation/bottom-tabs": ">=7.0.0",
     "@react-navigation/native": ">=7.0.0",
     "@react-navigation/stack": ">=7.0.0",
-    "@umituz/react-native-filesystem": "*",
     "@umituz/react-native-haptics": "*",
     "@umituz/react-native-localization": "*",
-    "@umituz/react-native-storage": "*",
     "@umituz/react-native-uuid": "*",
     "expo-application": ">=5.0.0",
     "expo-clipboard": ">=8.0.0",
@@ -111,10 +112,8 @@
     "@types/react-native": "^0.73.0",
     "@typescript-eslint/eslint-plugin": "^8.50.1",
     "@typescript-eslint/parser": "^8.50.1",
-    "@umituz/react-native-filesystem": "^2.1.7",
     "@umituz/react-native-haptics": "^1.0.2",
     "@umituz/react-native-localization": "^3.5.34",
-    "@umituz/react-native-storage": "^2.6.20",
     "@umituz/react-native-uuid": "*",
     "eslint": "^9.39.2",
     "eslint-plugin-react": "^7.37.5",
@@ -125,7 +124,7 @@
     "expo-crypto": "~14.0.0",
     "expo-device": "~7.0.2",
     "expo-file-system": "^19.0.21",
-    "expo-font": "~13.0.0",
+    "expo-font": "~14.0.0",
     "expo-network": "~8.0.0",
     "expo-video": "~3.0.0",
     "expo-haptics": "~14.0.0",

package/src/device/infrastructure/repositories/LegacyDeviceIdRepository.ts

@@ -1,4 +1,4 @@
-import { storageRepository, unwrap } from '@umituz/react-native-storage';
+import { storageRepository, unwrap } from '@storage';
 
 const LEGACY_DEVICE_ID_KEY = '@device/persistent_id';
 

package/src/device/infrastructure/services/DeviceFeatureService.ts

@@ -8,7 +8,7 @@
  * @layer infrastructure/services
  */
 
-import { storageRepository, unwrap } from '@umituz/react-native-storage';
+import { storageRepository, unwrap } from '@storage';
 import type {
   DeviceFeatureConfig,
   DeviceFeatureUsage,

package/src/exception/infrastructure/services/ExceptionLogger.ts

@@ -10,7 +10,7 @@
 
 import type { ExceptionEntity } from '../../domain/entities/ExceptionEntity';
 import { ExceptionHandler } from './ExceptionHandler';
-import { storageRepository } from '@umituz/react-native-storage';
+import { storageRepository } from '@storage';
 
 export class ExceptionLogger {
   private static readonly STORAGE_KEY = '@exceptions';

package/src/exception/infrastructure/storage/ExceptionStore.ts

@@ -3,7 +3,7 @@
  * Zustand store for exception state management
  */
 
-import { createStore } from '@umituz/react-native-storage';
+import { createStore } from '@storage';
 import type { ExceptionEntity } from '../../domain/entities/ExceptionEntity';
 
 interface ExceptionState {

package/src/exports/filesystem.ts

@@ -0,0 +1 @@
+export * from '../filesystem';

package/src/exports/storage.ts

@@ -0,0 +1 @@
+export * from '../storage';

package/src/filesystem/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/filesystem/domain/entities/File.ts

@@ -0,0 +1,20 @@
+/**
+ * File Entity - Module Index
+ * Domain layer exports for file operations
+ */
+
+// Types
+export type {
+  FileEncoding,
+  DirectoryType,
+  FileOperationResult,
+  FileInfo,
+  DownloadProgress,
+} from '../types/FileTypes';
+
+// Constants
+export { FILE_CONSTANTS } from '../constants/FileConstants';
+export type { AllowedExtension } from '../constants/FileConstants';
+
+// Utils
+export { FileUtils } from '../utils/FileUtils';

package/src/filesystem/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/filesystem/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/filesystem/index.ts

@@ -0,0 +1,23 @@
+/**
+ * @filesystem
+ */
+
+// Domain - Types and Utilities
+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.types";
+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 { 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";
+
+// Services - File Reading
+export { readFile, readFileAsBase64 } from "./infrastructure/services/file-reader.service";

package/src/filesystem/infrastructure/services/FileSystemService.ts

@@ -0,0 +1,45 @@
+/**
+ * FileSystem Service - Facade
+ */
+
+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 { FileOperationResult } from "../../domain/entities/File";
+
+export class FileSystemService {
+  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/filesystem/infrastructure/services/cache.service.ts

@@ -0,0 +1,48 @@
+/**
+ * Cache Service
+ * Single Responsibility: Manage cache directory operations
+ */
+
+import { getCacheDirectory, listDirectory } from "./directory.service";
+import { deleteFile } from "./file-manager.service";
+import { getFileInfo } from "./file-info.service";
+import { FileUtils } from "../../domain/entities/File";
+
+/**
+ * Clear cache directory
+ */
+export async function clearCache(): Promise<boolean> {
+  try {
+    const cacheDir = getCacheDirectory();
+    if (!cacheDir) return false;
+
+    const files = await listDirectory(cacheDir);
+    await Promise.all(
+      files.map((file) => deleteFile(FileUtils.joinPaths(cacheDir, file))),
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get total size of directory
+ */
+export async function getDirectorySize(uri: string): Promise<number> {
+  try {
+    const files = await listDirectory(uri);
+    const sizes = await Promise.all(
+      files.map(async (file) => {
+        const filePath = FileUtils.joinPaths(uri, file);
+        const info = await getFileInfo(filePath);
+        return info?.size || 0;
+      }),
+    );
+    return sizes.reduce((total, size) => total + size, 0);
+  } catch {
+    return 0;
+  }
+}
+
+

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

@@ -0,0 +1,66 @@
+/**
+ * Directory Service
+ * Single Responsibility: Manage directory operations
+ */
+
+import { Directory, Paths } from "expo-file-system";
+import type { DirectoryType } from "../../domain/entities/File";
+
+/**
+ * Create directory
+ */
+export async function createDirectory(uri: string): Promise<boolean> {
+  try {
+    const dir = new Directory(uri);
+    dir.create({ intermediates: true, idempotent: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * List directory contents
+ */
+export async function listDirectory(uri: string): Promise<string[]> {
+  try {
+    const dir = new Directory(uri);
+    const items = dir.list();
+    return items.map((item) => item.uri);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get directory path by type
+ */
+export function getDirectoryPath(type: DirectoryType): string {
+  try {
+    switch (type) {
+      case "documentDirectory":
+        return Paths.document.uri;
+      case "cacheDirectory":
+        return Paths.cache.uri;
+      default:
+        return "";
+    }
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Get document directory path
+ */
+export function getDocumentDirectory(): string {
+  return getDirectoryPath("documentDirectory");
+}
+
+/**
+ * Get cache directory path
+ */
+export function getCacheDirectory(): string {
+  return getDirectoryPath("cacheDirectory");
+}
+

package/src/filesystem/infrastructure/services/download.constants.ts

@@ -0,0 +1,6 @@
+/**
+ * Download Service Constants
+ */
+
+export const SUPPORTED_DOWNLOAD_EXTENSIONS = ["mp4", "mov", "m4v", "webm", "jpg", "png", "pdf"] as const;
+export const DEFAULT_DOWNLOAD_EXTENSION = "mp4" as const;

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

@@ -0,0 +1,74 @@
+/**
+ * Download Service
+ */
+
+import { File, Paths, Directory } from "expo-file-system";
+import type { FileOperationResult } from "../../domain/entities/File";
+import { FileUtils } from "../../domain/entities/File";
+import { SUPPORTED_DOWNLOAD_EXTENSIONS, DEFAULT_DOWNLOAD_EXTENSION } from "./download.constants";
+import type { DownloadProgressCallback, DownloadWithProgressResult } from "./download.types";
+
+const hashUrl = (url: 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);
+};
+
+const getExt = (url: string) => {
+  const parts = url.split("?")[0]?.split(".") || [];
+  const ext = parts.length > 1 ? parts.pop()?.toLowerCase() || DEFAULT_DOWNLOAD_EXTENSION : DEFAULT_DOWNLOAD_EXTENSION;
+  return (SUPPORTED_DOWNLOAD_EXTENSIONS as readonly string[]).includes(ext) ? ext : DEFAULT_DOWNLOAD_EXTENSION;
+};
+
+const getCacheUri = (url: string, dir: string) => FileUtils.joinPaths(dir, `cached_${hashUrl(url)}.${getExt(url)}`);
+
+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 (e: unknown) { return { success: false, error: e instanceof Error ? e.message : String(e) }; }
+}
+
+export async function downloadFileWithProgress(url: string, cacheDir: string, onProgress?: DownloadProgressCallback): Promise<DownloadWithProgressResult> {
+  try {
+    const dir = new Directory(cacheDir);
+    if (!dir.exists) dir.create({ intermediates: true, idempotent: true });
+
+    const destUri = getCacheUri(url, cacheDir);
+    if (new File(destUri).exists) return { success: true, uri: destUri, fromCache: true };
+
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    
+    const totalBytes = parseInt(response.headers.get("content-length") || "0", 10);
+    if (!response.body) return { ...(await downloadFile(url, destUri)), fromCache: false };
+
+    const reader = response.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let received = 0;
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      received += value.length;
+      onProgress?.({ totalBytesWritten: received, totalBytesExpectedToWrite: totalBytes || received });
+    }
+
+    const all = new Uint8Array(received);
+    let pos = 0;
+    for (const c of chunks) { all.set(c, pos); pos += c.length; }
+    new File(destUri).write(all);
+
+    return { success: true, uri: destUri, fromCache: false };
+  } catch (e: unknown) { return { success: false, error: e instanceof Error ? e.message : String(e) }; }
+}
+
+export const isUrlCached = (url: string, dir: string) => new File(getCacheUri(url, dir)).exists;
+export const getCachedFileUri = (url: string, dir: string) => isUrlCached(url, dir) ? getCacheUri(url, dir) : null;
+export const deleteCachedFile = (url: string, dir: string) => {
+  const f = new File(getCacheUri(url, dir));
+  if (f.exists) f.delete();
+  return true;
+};

package/src/filesystem/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/filesystem/infrastructure/services/encoding.service.ts

@@ -0,0 +1,25 @@
+/**
+ * Encoding Service
+ * Single Responsibility: Handle file encoding/decoding operations
+ */
+
+import type { FileEncoding } from "../../domain/entities/File";
+
+/**
+ * Encoding type for Expo FileSystem
+ */
+export type ExpoEncodingType = FileEncoding;
+
+/**
+ * Convert FileEncoding to Expo FileSystem encoding type
+ */
+export function getEncodingType(encoding: FileEncoding): ExpoEncodingType {
+  return encoding;
+}
+
+/**
+ * Validate encoding type
+ */
+export function isValidEncoding(encoding: string): encoding is FileEncoding {
+  return encoding === "utf8" || encoding === "base64";
+}

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

@@ -0,0 +1,52 @@
+/**
+ * File Info Service
+ * Single Responsibility: Get file information and metadata
+ */
+
+import { File } from "expo-file-system";
+import type { FileInfo } from "../../domain/entities/File";
+
+/**
+ * Get file information
+ */
+export async function getFileInfo(uri: string): Promise<FileInfo | null> {
+  try {
+    const file = new File(uri);
+
+    if (!file.exists) {
+      return null;
+    }
+
+    return {
+      uri,
+      name: file.name,
+      size: file.size || 0,
+      exists: file.exists,
+      isDirectory: false,
+      modificationTime: file.modificationTime || 0,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if file exists
+ */
+export async function fileExists(uri: string): Promise<boolean> {
+  try {
+    const file = new File(uri);
+    return file.exists;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get file size
+ */
+export async function getFileSize(uri: string): Promise<number> {
+  const info = await getFileInfo(uri);
+  return info?.size || 0;
+}
+