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

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

@@ -0,0 +1,81 @@
+/**
+ * File Manager Service
+ * Single Responsibility: Manage file operations (delete, copy, move)
+ */
+
+import { File, Directory } from "expo-file-system";
+import type { FileOperationResult } from "../../domain/entities/File";
+
+/**
+ * Delete file or directory
+ */
+export async function deleteFile(uri: string): Promise<boolean> {
+  try {
+    // Try as file first
+    try {
+      const file = new File(uri);
+      if (file.exists) {
+        file.delete();
+        return true;
+      }
+    } catch {
+      // Not a file, try as directory
+    }
+
+    // Try as directory
+    try {
+      const dir = new Directory(uri);
+      if (dir.exists) {
+        dir.delete();
+        return true;
+      }
+    } catch {
+      // Not a directory either
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Copy file
+ */
+export async function copyFile(
+  sourceUri: string,
+  destinationUri: string,
+): Promise<FileOperationResult> {
+  try {
+    const sourceFile = new File(sourceUri);
+    const destination = new File(destinationUri);
+    sourceFile.copy(destination);
+    return { success: true, uri: destinationUri };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+
+/**
+ * Move file
+ */
+export async function moveFile(
+  sourceUri: string,
+  destinationUri: string,
+): Promise<FileOperationResult> {
+  try {
+    const sourceFile = new File(sourceUri);
+    const destination = new File(destinationUri);
+    sourceFile.move(destination);
+    return { success: true, uri: destinationUri };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+

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

@@ -0,0 +1,22 @@
+/**
+ * File Path Service
+ * Single Responsibility: Generate and manage file paths
+ */
+
+import type { DirectoryType } from "../../domain/entities/File";
+import { getDirectoryPath } from "./directory.service";
+import { FileUtils } from "../../domain/entities/File";
+
+/**
+ * Generate unique file path in specified directory
+ */
+export function generateFilePath(
+  filename: string,
+  directory: DirectoryType = "documentDirectory",
+): string {
+  const dirPath = getDirectoryPath(directory);
+  const uniqueFilename = FileUtils.generateUniqueFilename(filename);
+  return FileUtils.joinPaths(dirPath, uniqueFilename);
+}
+
+

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

@@ -0,0 +1,52 @@
+/**
+ * File Reader Service
+ * Single Responsibility: Read files from device storage
+ */
+
+import { File } from "expo-file-system";
+import type { FileEncoding } from "../../domain/entities/File";
+import { blobToBase64 } from "../utils/blob.utils";
+
+/**
+ * Read file as string with encoding
+ */
+export async function readFile(
+  uri: string,
+  encoding: FileEncoding = "utf8",
+): Promise<string | null> {
+  try {
+    // For file:// URLs, try fetch first (works in React Native)
+    if (uri.startsWith("file://")) {
+      try {
+        const response = await fetch(uri);
+        if (response.ok) {
+          if (encoding === "base64") {
+            const blob = await response.blob();
+            return await blobToBase64(blob);
+          }
+          return await response.text();
+        }
+      } catch {
+        // Fall through to FileSystem API
+      }
+    }
+
+    // Use FileSystem API as fallback
+    const file = new File(uri);
+    if (encoding === "base64") {
+      const content = await file.base64();
+      return content;
+    }
+    const content = await file.text();
+    return content;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read file as base64 string
+ */
+export async function readFileAsBase64(uri: string): Promise<string | null> {
+  return readFile(uri, "base64");
+}

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

@@ -0,0 +1,32 @@
+/**
+ * File Writer Service
+ * Single Responsibility: Write files to device storage
+ */
+
+import { File } from "expo-file-system";
+import type { FileEncoding, FileOperationResult } from "../../domain/entities/File";
+import { getEncodingType, type ExpoEncodingType } from "./encoding.service";
+
+/**
+ * Write string to file
+ */
+export async function writeFile(
+  uri: string,
+  content: string,
+  encoding: FileEncoding = "utf8",
+): Promise<FileOperationResult> {
+  try {
+    const encodingType = getEncodingType(encoding);
+    const file = new File(uri);
+    file.write(content, {
+      encoding: encodingType as ExpoEncodingType,
+    });
+    return { success: true, uri };
+  } catch (error) {
+    const writeError = error as Error;
+    return {
+      success: false,
+      error: writeError.message || "Unknown error",
+    };
+  }
+}

package/src/filesystem/infrastructure/utils/blob.utils.ts

@@ -0,0 +1,20 @@
+/**
+ * Blob Utils
+ * Blob utility functions for file operations
+ */
+
+/**
+ * Convert blob to base64 string
+ */
+export function blobToBase64(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      const result = reader.result as string;
+      const base64 = result.includes(",") ? result.split(",")[1] ?? result : result;
+      resolve(base64);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}

package/src/image/infrastructure/services/ImageStorageService.ts

@@ -4,7 +4,7 @@
  * Handles saving images to the device filesystem
  */
 
-import { FileSystemService } from '@umituz/react-native-filesystem';
+import { FileSystemService } from '@filesystem';
 import { ImageValidator } from '../utils/ImageValidator';
 import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
 

package/src/index.ts

@@ -102,7 +102,16 @@ export * from './exports/variants';
 // =============================================================================
 export * from './exports/utilities';
 
+// =============================================================================
+// STORAGE EXPORTS
+// =============================================================================
+export * from './exports/storage';
+
 // =============================================================================
 // ONBOARDING EXPORTS
 // =============================================================================
 export * from './exports/onboarding';
+// =============================================================================
+// FILESYSTEM EXPORTS
+// =============================================================================
+export * from './exports/filesystem';

package/src/molecules/alerts/AlertStore.ts

@@ -2,7 +2,7 @@
  * Alert Store
  */
 
-import { createStore } from '@umituz/react-native-storage';
+import { createStore } from '@storage';
 import { Alert } from './AlertTypes';
 
 interface AlertState {

package/src/molecules/calendar/infrastructure/storage/EventActions.ts

@@ -3,7 +3,7 @@
  * Event CRUD operations for calendar store
  */
 
-import { storageRepository, unwrap } from '@umituz/react-native-storage';
+import { storageRepository, unwrap } from '@storage';
 import type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest } from '../../domain/entities/CalendarEvent.entity';
 import { generateId, STORAGE_KEY, hydrateEvents, handleStorageError, handleStorageSuccess } from './CalendarStore.utils';
 import type { CalendarState } from './CalendarStore.types';

package/src/molecules/calendar/infrastructure/stores/storageAdapter.ts

@@ -3,7 +3,7 @@
  * Converts AsyncStorageRepository to Zustand-compatible storage
  */
 
-import { storageRepository } from '@umituz/react-native-storage';
+import { storageRepository } from '@storage';
 
 export const zustandStorage = {
   getItem: async (name: string): Promise<string | null> => {

package/src/offline/infrastructure/storage/OfflineStore.ts

@@ -4,7 +4,7 @@
  * Uses expo-network for universal network detection
  */
 
-import { createStore } from '@umituz/react-native-storage';
+import { createStore } from '@storage';
 import type { NetworkState, OfflineState, OfflineActions } from '../../types';
 
 const initialState: OfflineState = {

package/src/onboarding/infrastructure/storage/OnboardingStore.ts

@@ -2,11 +2,11 @@
  * Onboarding Store
  *
  * Zustand store for managing onboarding completion state
- * Uses @umituz/react-native-storage for persistence
+ * Uses @storage for persistence
  */
 
 import { useMemo } from "react";
-import { createStore } from "@umituz/react-native-storage";
+import { createStore } from "@storage";
 import type { OnboardingStoreState } from "./OnboardingStoreState";
 import { initialOnboardingState } from "./OnboardingStoreState";
 import { createOnboardingStoreActions } from "./OnboardingStoreActions";

package/src/onboarding/infrastructure/storage/__tests__/OnboardingStore.test.ts

@@ -6,7 +6,7 @@ import { renderHook, act } from '@testing-library/react-native';
 import { useOnboardingStore, useOnboarding } from '../OnboardingStore';
 
 // Mock storage repository
-jest.mock('@umituz/react-native-storage', () => ({
+jest.mock('@storage', () => ({
   storageRepository: {
     getString: jest.fn(),
     setString: jest.fn(),

package/src/onboarding/infrastructure/storage/actions/answerActions.ts

@@ -3,7 +3,7 @@
  * Single Responsibility: Save and update user answers
  */
 
-import { storageRepository } from "@umituz/react-native-storage";
+import { storageRepository } from "@storage";
 import type { OnboardingUserData } from "../../../domain/entities/OnboardingUserData";
 import type { OnboardingStoreState } from "../OnboardingStoreState";
 import { USER_DATA_STORAGE_KEY, handleError, logSuccess } from "./storageHelpers";

package/src/onboarding/infrastructure/storage/actions/storageHelpers.ts

@@ -3,7 +3,7 @@
  * Single Responsibility: Common storage operations and error handling
  */
 
-import { storageRepository, unwrap } from "@umituz/react-native-storage";
+import { storageRepository, unwrap } from "@storage";
 import type { OnboardingUserData } from "../../../domain/entities/OnboardingUserData";
 
 export const DEFAULT_STORAGE_KEY = "@onboarding:completed";

package/src/storage/README.md

@@ -0,0 +1,185 @@
+# Source Directory
+
+Main source code for react-native-storage package following Domain-Driven Design principles.
+
+## Overview
+
+Complete implementation of storage and caching solution with Clean Architecture. Located at `src/`.
+
+## Architecture
+
+Clean Architecture with DDD principles:
+- `application/` - Application layer (ports/interfaces)
+- `cache/` - In-memory caching module
+- `domain/` - Domain layer (business logic)
+- `infrastructure/` - Infrastructure layer (implementations)
+- `presentation/` - Presentation layer (React hooks)
+- `types/` - Shared TypeScript types
+
+## Strategies
+
+### Layer Organization
+- Use application layer for interfaces and ports
+- Use domain layer for business logic and entities
+- Use infrastructure layer for external service implementations
+- Use presentation layer for React integration
+- Use cache module for in-memory caching
+
+### Dependency Flow
+- Presentation depends on domain
+- Domain depends on nothing (core)
+- Infrastructure implements domain interfaces
+- Application defines contracts between layers
+
+### Module Separation
+- Keep cache module independent and self-contained
+- Enable cache usage without storage dependency
+- Support standalone cache operations
+- Maintain clean module boundaries
+
+### Type Safety
+- Use TypeScript for all modules
+- Provide generic type parameters
+- Enable type inference
+- Support branded types for storage keys
+
+## Restrictions
+
+### Layer Dependencies
+- DO NOT import infrastructure in domain layer
+- DO NOT import presentation in domain layer
+- DO NOT import application in infrastructure
+- DO NOT create circular dependencies
+
+### Module Boundaries
+- DO NOT mix concerns across layers
+- DO NOT bypass layer boundaries
+- DO NOT expose implementation details
+- DO NOT create tight coupling between modules
+
+### Code Organization
+- DO NOT place business logic in presentation
+- DO NOT place UI code in domain
+- DO NOT place external dependencies in domain
+- DO NOT create god objects
+
+### Architecture Compliance
+- DO NOT violate dependency inversion principle
+- DO NOT ignore layer responsibilities
+- DO NOT create ambiguous module placement
+- DO NOT mix abstraction levels
+
+## Rules
+
+### Application Layer
+- MUST define IStorageRepository interface
+- MUST provide ports for dependency inversion
+- MUST not contain implementation details
+- MUST be framework-agnostic
+- MUST enable constructor injection
+
+### Cache Module
+- MUST provide domain entities (CacheManager, CachedValue)
+- MUST provide infrastructure implementation (TTLCache)
+- MUST provide presentation hooks (useCache, useCachedValue)
+- MUST support multiple eviction strategies (LRU, LFU, FIFO, TTL)
+- MUST be independent and self-contained
+
+### Domain Layer
+- MUST contain core business logic
+- MUST define value objects (StorageKey)
+- MUST define entities (CachedValue, Result)
+- MUST provide factory functions (createStore)
+- MUST define error types (StorageError hierarchy)
+- MUST not depend on external frameworks
+
+### Infrastructure Layer
+- MUST implement IStorageRepository interface
+- MUST provide StorageService adapter for Zustand
+- MUST handle Result pattern for error handling
+- MUST support AsyncStorage as primary backend
+- MUST enable custom storage backends
+
+### Presentation Layer
+- MUST provide React hooks for storage
+- MUST provide React hooks for cache
+- MUST enable reactive state management
+- MUST handle loading and error states
+- MUST follow React hooks rules
+
+### Types Module
+- MUST provide shared TypeScript types
+- MUST define StorageResult type
+- MUST define DynamicStorageKey type
+- MUST enable type-safe operations
+- MUST be imported by all layers
+
+### Export Structure
+- MUST export from index.ts at root level
+- MUST organize exports by module
+- MUST provide TypeScript types
+- MUST maintain backward compatibility
+- MUST not export internal utilities
+
+### File Organization
+- MUST place files in appropriate layer
+- MUST follow feature-based organization within layers
+- MUST use descriptive file names
+- MUST maintain consistent structure
+- MUST enable easy navigation
+
+### Testing Structure
+- MUST place tests in __tests__ directories
+- MUST mirror source structure
+- MUST provide comprehensive coverage
+- MUST enable isolated testing
+- MUST not depend on external services
+
+### Type Safety Requirements
+- MUST use TypeScript for all files
+- MUST provide generic type parameters
+- MUST enable type inference
+- MUST not use `any` type
+- MUST enforce strict type checking
+
+### Error Handling
+- MUST use Result pattern for operations
+- MUST preserve error context
+- MUST provide hierarchical error types
+- MUST not throw exceptions across layers
+- MUST handle errors gracefully
+
+### Documentation
+- MUST provide README for each layer
+- MUST document public APIs
+- MUST specify file locations
+- MUST explain architecture decisions
+- MUST not include code examples in README files
+
+### Naming Conventions
+- MUST use camelCase for files and variables
+- MUST use PascalCase for types and interfaces
+- MUST use descriptive names
+- MUST follow React hooks naming (use prefix)
+- MUST maintain consistency across modules
+
+### Performance Considerations
+- MUST optimize for read-heavy or write-heavy patterns
+- MUST minimize unnecessary re-renders
+- MUST use memoization where appropriate
+- MUST enable lazy loading
+- MUST consider bundle size impact
+
+### Security Requirements
+- MUST not expose sensitive data in logs
+- MUST use SecureStore for sensitive data
+- MUST handle encryption for secure storage
+- MUST validate input data
+- MUST prevent injection attacks
+
+### Best Practices Compliance
+- MUST follow Single Responsibility Principle
+- MUST follow Open/Closed Principle
+- MUST follow Liskov Substitution Principle
+- MUST follow Interface Segregation Principle
+- MUST follow Dependency Inversion Principle