@umituz/react-native-design-system 4.23.97 → 4.23.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "4.23.97",
+  "version": "4.23.101",
   "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, onboarding, and loading utilities",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/atoms/AtomicInput.tsx

@@ -57,9 +57,7 @@ export const AtomicInput = React.forwardRef<React.ElementRef<typeof TextInput>,
     value,
     onChangeText,
     secureTextEntry,
-    showPasswordToggle,
     maxLength,
-    showCharacterCount,
   });
 
   const isDisabled = state === 'disabled' || disabled;

package/src/atoms/button/AtomicButton.tsx

@@ -29,6 +29,9 @@ export const AtomicButton: React.FC<AtomicButtonProps> = React.memo(({
   textStyle,
   activeOpacity = 0.8,
   testID,
+  accessibilityLabel,
+  accessibilityHint,
+  accessibilityRole = 'button',
 }) => {
   const tokens = useAppDesignTokens();
 
@@ -80,6 +83,10 @@ export const AtomicButton: React.FC<AtomicButtonProps> = React.memo(({
       activeOpacity={activeOpacity}
       disabled={isDisabled}
       testID={testID}
+      accessibilityRole={accessibilityRole}
+      accessibilityLabel={accessibilityLabel || title || (typeof children === 'string' ? children : 'Button')}
+      accessibilityHint={accessibilityHint}
+      accessibilityState={{ disabled: isDisabled, busy: loading }}
     >
       {loading ? (
         <AtomicSpinner

package/src/atoms/button/types/index.ts

@@ -24,6 +24,10 @@ export interface AtomicButtonProps {
   readonly textStyle?: StyleProp<TextStyle>;
   readonly activeOpacity?: number;
   readonly testID?: string;
+  // Accessibility props
+  readonly accessibilityLabel?: string;
+  readonly accessibilityHint?: string;
+  readonly accessibilityRole?: 'button' | 'link';
 }
 
 export interface ButtonSizeConfig {

package/src/atoms/input/hooks/useInputState.ts

@@ -1,12 +1,10 @@
-import { useState, useCallback, useEffect } from 'react';
+import { useState, useCallback, useEffect, useMemo } from 'react';
 
 interface UseInputStateProps {
   value?: string;
   onChangeText?: (text: string) => void;
   secureTextEntry?: boolean;
-  showPasswordToggle?: boolean;
   maxLength?: number;
-  showCharacterCount?: boolean;
 }
 
 interface UseInputStateReturn {
@@ -24,9 +22,7 @@ export const useInputState = ({
   value = '',
   onChangeText,
   secureTextEntry = false,
-  showPasswordToggle: _showPasswordToggle = false,
   maxLength,
-  showCharacterCount: _showCharacterCount = false,
 }: UseInputStateProps = {}): UseInputStateReturn => {
   const [localValue, setLocalValue] = useState(value);
   const [isFocused, setIsFocused] = useState(false);
@@ -49,7 +45,7 @@ export const useInputState = ({
   const characterCount = localValue.length;
   const isAtMaxLength = maxLength ? characterCount >= maxLength : false;
 
-  return {
+  return useMemo(() => ({
     localValue,
     isFocused,
     isPasswordVisible,
@@ -58,5 +54,5 @@ export const useInputState = ({
     setIsFocused,
     handleTextChange,
     togglePasswordVisibility,
-  };
+  }), [localValue, isFocused, isPasswordVisible, characterCount, isAtMaxLength, handleTextChange, togglePasswordVisibility]);
 };

package/src/haptics/infrastructure/services/HapticService.ts

@@ -15,7 +15,7 @@ import type { ImpactStyle, NotificationType, HapticPattern } from '../../domain/
  * Log error in development mode only
  */
 function logError(method: string, error: unknown): void {
-  if (process.env.NODE_ENV === 'development') {
+  if (__DEV__) {
     console.error(`[DesignSystem] HapticService.${method} error:`, error);
   }
 }

package/src/media/domain/entities/{MultimediaFlashcardTypes.ts → MediaAttachments.ts}

@@ -1,22 +1,22 @@
 /**
- * Multimedia Flashcard Types
- * Extended media types for flashcard support
+ * Media Attachments Types
+ * Types for media attachments in flashcards and content
  */
 
-export type MediaType = "image" | "audio" | "video";
+export type MediaAttachmentType = "image" | "audio" | "video";
 export type MediaPosition = "front" | "back" | "both";
 
 export interface MediaAttachment {
   id: string;
-  type: MediaType;
+  type: MediaAttachmentType;
   position: MediaPosition;
   url: string;
   localPath?: string;
   filename: string;
   fileSize: number;
   mimeType: string;
-  duration?: number; // For audio/video in seconds
-  thumbnailUrl?: string; // For videos
+  duration?: number;
+  thumbnailUrl?: string;
   caption?: string;
   isDownloaded: boolean;
   createdAt: string;
@@ -30,12 +30,11 @@ export interface MultimediaFlashcard {
   tags: string[];
   createdAt?: string;
   updatedAt?: string;
-  // Extended properties for multimedia support
   media: MediaAttachment[];
-  hasMedia: boolean; // Computed property
-  mediaType: MediaType[]; // Array of media types present
-  isDownloaded: boolean; // All media downloaded?
-  estimatedSize: number; // Total size in bytes
+  hasMedia: boolean;
+  mediaType: MediaAttachmentType[];
+  isDownloaded: boolean;
+  estimatedSize: number;
 }
 
 export interface MediaGenerationRequest {
@@ -65,17 +64,17 @@ export interface MediaGenerationResult {
 
 export interface MediaUploadProgress {
   fileId: string;
-  progress: number; // 0-100
+  progress: number;
   status: "uploading" | "processing" | "completed" | "error";
   error?: string;
   url?: string;
 }
 
 export interface MediaCompressionOptions {
-  quality: number; // 0.1 - 1.0
+  quality: number;
   maxWidth?: number;
   maxHeight?: number;
-  maxFileSize?: number; // bytes
+  maxFileSize?: number;
   format?: "jpeg" | "png" | "webp";
 }
 
@@ -100,21 +99,3 @@ export interface MediaValidation {
   warnings: string[];
   recommendations: string[];
 }
-
-export interface MultimediaFlashcardService {
-  uploadMedia(
-    file: MediaFile,
-    options?: MediaCompressionOptions,
-  ): Promise<MediaAttachment>;
-  generateMedia(
-    request: MediaGenerationRequest,
-  ): Promise<MediaGenerationResult>;
-  validateMedia(file: MediaFile): Promise<MediaValidation>;
-  optimizeMedia(
-    attachment: MediaAttachment,
-    options: MediaCompressionOptions,
-  ): Promise<MediaAttachment>;
-  deleteMedia(attachmentId: string): Promise<void>;
-  getMediaUrl(attachmentId: string): Promise<string>;
-  downloadMedia(attachmentId: string): Promise<string>; // Returns local path
-}

package/src/media/index.ts

@@ -91,28 +91,29 @@ export {
   type SaveToGalleryResult,
 } from "./infrastructure/utils/file-media-utils";
 
-// Multimedia Flashcard Support
+// Media Attachment Types (Clean, no aliases)
 export type {
-  CardMediaType,
-  CardMediaPosition,
-  CardMediaAttachment,
-  CardMultimediaFlashcard,
-  CardMediaGenerationRequest,
-  CardMediaGenerationResult,
-  CardMediaUploadProgress,
-  CardMediaCompressionOptions,
-  CardMediaValidation,
-} from "./domain/entities/CardMultimedia.types";
+  MediaAttachmentType,
+  MediaPosition,
+  MediaAttachment,
+  MultimediaFlashcard,
+  MediaGenerationRequest,
+  MediaGenerationResult,
+  MediaUploadProgress,
+  MediaCompressionOptions,
+  MediaValidation,
+  MediaFile,
+  CreateMultimediaCardData,
+} from "./domain/entities/MediaAttachments";
 
-export { CardMultimediaFlashcardService } from "./infrastructure/services/CardMultimediaService";
-
-export {
-  useCardMediaUpload,
-  useCardMediaGeneration,
-  useCardMediaValidation,
-  useCardMultimediaFlashcard,
-  type UseCardMediaUploadResult,
-  type UseCardMediaGenerationResult,
-  type UseCardMediaValidationResult,
-  type UseCardMultimediaFlashcardResult,
-} from "./presentation/hooks/useCardMultimediaFlashcard";
+// Media Hooks
+export { useMediaUpload } from "./presentation/hooks/useMediaUpload";
+export { useMediaGeneration } from "./presentation/hooks/useMediaGeneration";
+export { useMediaValidation } from "./presentation/hooks/useMediaValidation";
+export { useMultimediaFlashcard } from "./presentation/hooks/useMultimediaFlashcard";
+export type {
+  UseMediaUploadResult,
+  UseMediaGenerationResult,
+  UseMediaValidationResult,
+  UseMultimediaFlashcardResult,
+} from "./presentation/hooks/multimedia.types";

package/src/media/{presentation/hooks/useCardMediaGeneration.ts → infrastructure/hooks/useGenericMediaGeneration.ts}

@@ -1,26 +1,75 @@
 /**
- * Card Media Generation Hook
- * Hook for generating card media with AI
+ * Generic Media Generation Hook
+ * Shared implementation for both Media and CardMedia generation
+ * Eliminates ~600 LOC duplication
  */
 
 import { useState, useCallback } from "react";
-import type { UseCardMediaGenerationResult } from "./card-multimedia.types";
-import type {
-  CardMediaAttachment,
-  CardMediaGenerationRequest,
-  CardMediaGenerationResult,
-} from "../../domain/entities/CardMultimedia.types";
-
-export const useCardMediaGeneration = (): UseCardMediaGenerationResult => {
+
+interface GenericMediaAttachment {
+  id: string;
+  type: string;
+  position: string;
+  url: string;
+  filename: string;
+  fileSize: number;
+  mimeType: string;
+  duration?: number;
+  thumbnailUrl?: string;
+  caption?: string;
+  isDownloaded: boolean;
+  createdAt: string;
+}
+
+interface GenericMediaGenerationRequest {
+  type: "text_to_image" | "text_to_audio" | "image_search";
+  input: {
+    text?: string;
+    prompt?: string;
+    language?: string;
+    voice?: "male" | "female" | "neutral";
+    style?: "realistic" | "cartoon" | "artistic";
+  };
+  options: {
+    maxResults?: number;
+    quality?: "low" | "medium" | "high";
+    format?: "jpeg" | "png" | "mp3" | "wav";
+  };
+}
+
+interface GenericMediaGenerationResult<TAttachment> {
+  success: boolean;
+  attachments: TAttachment[];
+  creditsUsed: number;
+  processingTime: number;
+  error?: string;
+  requestId: string;
+}
+
+export interface UseGenericMediaGenerationResult<TAttachment, TRequest> {
+  generateMedia: (request: TRequest) => Promise<GenericMediaGenerationResult<TAttachment>>;
+  isGenerating: boolean;
+  generationResult: GenericMediaGenerationResult<TAttachment> | null;
+  error: string | null;
+}
+
+/**
+ * Generic implementation of media generation logic
+ * Type-safe through attachment factory pattern
+ */
+export function useGenericMediaGeneration<
+  TAttachment extends GenericMediaAttachment,
+  TRequest extends GenericMediaGenerationRequest
+>(
+  attachmentFactory: (baseAttachment: GenericMediaAttachment) => TAttachment
+): UseGenericMediaGenerationResult<TAttachment, TRequest> {
   const [isGenerating, setIsGenerating] = useState(false);
   const [generationResult, setGenerationResult] =
-    useState<CardMediaGenerationResult | null>(null);
+    useState<GenericMediaGenerationResult<TAttachment> | null>(null);
   const [error, setError] = useState<string | null>(null);
 
   const generateMedia = useCallback(
-    async (
-      request: CardMediaGenerationRequest,
-    ): Promise<CardMediaGenerationResult> => {
+    async (request: TRequest): Promise<GenericMediaGenerationResult<TAttachment>> => {
       try {
         setIsGenerating(true);
         setError(null);
@@ -28,18 +77,18 @@ export const useCardMediaGeneration = (): UseCardMediaGenerationResult => {
         // Simulate generation
         await new Promise((resolve) => setTimeout(resolve, 3000));
 
-        const attachments: CardMediaAttachment[] = [];
+        const baseAttachments: GenericMediaAttachment[] = [];
 
         switch (request.type) {
           case "text_to_image":
             for (let i = 0; i < (request.options.maxResults || 1); i++) {
-              attachments.push({
+              baseAttachments.push({
                 id: `ai_img_${Date.now()}_${i}`,
                 type: "image",
                 position: "both",
                 url: `https://picsum.photos/400/300?random=${Date.now() + i}`,
                 filename: `ai_generated_${i}.jpg`,
-                fileSize: 150000, // 150KB
+                fileSize: 150000,
                 mimeType: "image/jpeg",
                 isDownloaded: false,
                 createdAt: new Date().toISOString(),
@@ -48,15 +97,15 @@ export const useCardMediaGeneration = (): UseCardMediaGenerationResult => {
             break;
 
           case "text_to_audio":
-            attachments.push({
+            baseAttachments.push({
               id: `ai_audio_${Date.now()}`,
               type: "audio",
               position: "back",
               url: `https://example.com/audio_${Date.now()}.mp3`,
               filename: `ai_generated_${Date.now()}.mp3`,
-              fileSize: 80000, // 80KB
+              fileSize: 80000,
               mimeType: "audio/mp3",
-              duration: 10, // 10 seconds
+              duration: 10,
               isDownloaded: false,
               createdAt: new Date().toISOString(),
             });
@@ -64,13 +113,13 @@ export const useCardMediaGeneration = (): UseCardMediaGenerationResult => {
 
           case "image_search":
             for (let i = 0; i < (request.options.maxResults || 5); i++) {
-              attachments.push({
+              baseAttachments.push({
                 id: `search_img_${Date.now()}_${i}`,
                 type: "image",
                 position: "both",
                 url: `https://picsum.photos/400/300?random=${Date.now() + i}`,
                 filename: `search_result_${i}.jpg`,
-                fileSize: 120000, // 120KB
+                fileSize: 120000,
                 mimeType: "image/jpeg",
                 isDownloaded: false,
                 createdAt: new Date().toISOString(),
@@ -79,15 +128,12 @@ export const useCardMediaGeneration = (): UseCardMediaGenerationResult => {
             break;
         }
 
-        const result: CardMediaGenerationResult = {
+        const attachments = baseAttachments.map(attachmentFactory);
+
+        const result: GenericMediaGenerationResult<TAttachment> = {
           success: true,
           attachments,
-          creditsUsed:
-            request.type === "text_to_image"
-              ? 5
-              : request.type === "text_to_audio"
-                ? 3
-                : 2,
+          creditsUsed: request.type === "text_to_image" ? 5 : request.type === "text_to_audio" ? 3 : 2,
           processingTime: 3000,
           requestId: `req_${Date.now()}`,
         };
@@ -112,7 +158,7 @@ export const useCardMediaGeneration = (): UseCardMediaGenerationResult => {
         setIsGenerating(false);
       }
     },
-    [],
+    [attachmentFactory],
   );
 
   return {
@@ -121,4 +167,4 @@ export const useCardMediaGeneration = (): UseCardMediaGenerationResult => {
     generationResult,
     error,
   };
-};
+}

package/src/media/infrastructure/services/MediaGenerationService.ts

@@ -9,7 +9,7 @@ import type {
   MediaGenerationResult,
   MediaType,
   MediaPosition,
-} from "../../domain/entities/MultimediaFlashcardTypes";
+} from "../../domain/entities/MediaAttachments";
 
 export class MediaGenerationService {
   /**

package/src/media/infrastructure/services/MediaOptimizerService.ts

@@ -6,7 +6,7 @@
 import type {
   MediaAttachment,
   MediaCompressionOptions,
-} from "../../domain/entities/MultimediaFlashcardTypes";
+} from "../../domain/entities/MediaAttachments";
 
 export class MediaOptimizerService {
   /**

package/src/media/infrastructure/services/MediaUploadService.ts

@@ -7,7 +7,7 @@ import type {
   MediaAttachment,
   MediaCompressionOptions,
   MediaFile,
-} from "../../domain/entities/MultimediaFlashcardTypes";
+} from "../../domain/entities/MediaAttachments";
 import { generateThumbnail, getMediaDuration } from "../utils/file-media-utils";
 import { getMediaTypeFromMime } from "../utils/mime-type-detector";
 

package/src/media/infrastructure/services/MediaValidationService.ts

@@ -4,7 +4,7 @@
  */
 
 import { formatFileSize } from "../utils/media-collection-utils";
-import type { MediaValidation, MediaFile } from "../../domain/entities/MultimediaFlashcardTypes";
+import type { MediaValidation, MediaFile } from "../../domain/entities/MediaAttachments";
 
 export class MediaValidationService {
   /**

package/src/media/infrastructure/services/MultimediaFlashcardService.ts

@@ -10,7 +10,7 @@ import type {
   MediaGenerationResult,
   MediaCompressionOptions,
   MediaValidation,
-} from "../../domain/entities/MultimediaFlashcardTypes";
+} from "../../domain/entities/MediaAttachments";
 import { MediaUploadService } from "./MediaUploadService";
 import { MediaGenerationService } from "./MediaGenerationService";
 import { MediaValidationService } from "./MediaValidationService";

package/src/media/infrastructure/utils/PermissionManager.ts

@@ -5,7 +5,7 @@
  */
 
 import * as ImagePicker from "expo-image-picker";
-import { MediaLibraryPermission } from "../../domain/entities/Media";
+import { MediaLibraryPermission } from "../../domain/entities/MediaAttachments";
 import { mapPermissionStatus } from "./mediaPickerMappers";
 
 /**

package/src/media/infrastructure/utils/media-collection-utils.ts

@@ -1,5 +1,7 @@
-import type { CardMediaAttachment } from "../../domain/entities/CardMultimedia.types";
-import type { MediaAttachment } from "../../domain/entities/MultimediaFlashcardTypes";
+import type { MediaAttachment } from "../../domain/entities/MediaAttachments";
+
+// CardMediaAttachment is an alias of MediaAttachment
+type CardMediaAttachment = MediaAttachment;
 
 type MediaType = "image" | "audio" | "video";
 

package/src/media/infrastructure/utils/mediaPickerMappers.ts

@@ -9,7 +9,7 @@ import {
   MediaType,
   type MediaAsset,
   type MediaPickerResult,
-} from "../../domain/entities/Media";
+} from "../../domain/entities/MediaAttachments";
 
 /**
  * Map expo-image-picker permission status to MediaLibraryPermission

package/src/media/presentation/hooks/multimedia.types.ts

@@ -13,7 +13,7 @@ import type {
   MediaUploadProgress,
   MultimediaFlashcard,
   CreateMultimediaCardData,
-} from "../../domain/entities/MultimediaFlashcardTypes";
+} from "../../domain/entities/MediaAttachments";
 
 export interface UseMediaUploadResult {
   uploadMedia: (

package/src/media/presentation/hooks/useCardMultimediaFlashcard.ts

@@ -7,10 +7,10 @@ import { useState, useCallback } from "react";
 import { calculateTotalSize, extractMediaTypes } from "../../infrastructure/utils/media-collection-utils";
 import type { UseCardMultimediaFlashcardResult } from "./card-multimedia.types";
 import type {
-  CardMediaAttachment,
-  CardMultimediaFlashcard,
-  CreateCardMultimediaData,
-} from "../../domain/entities/CardMultimedia.types";
+  MediaAttachment as CardMediaAttachment,
+  MultimediaFlashcard as CardMultimediaFlashcard,
+  CreateMultimediaCardData as CreateCardMultimediaData,
+} from "../../domain/entities/MediaAttachments";
 
 // Export individual hooks
 export { useCardMediaUpload } from "./useCardMediaUpload";

package/src/media/presentation/hooks/useMedia.ts

@@ -12,8 +12,8 @@ import type {
   MediaPickerOptions,
   MediaPickerResult,
   CameraOptions,
-} from "../../domain/entities/Media";
-import { MediaLibraryPermission } from "../../domain/entities/Media";
+} from "../../domain/entities/MediaAttachments";
+import { MediaLibraryPermission } from "../../domain/entities/MediaAttachments";
 
 /**
  * useMedia hook for complete media workflow

package/src/media/presentation/hooks/useMediaGeneration.ts

@@ -1,101 +1,18 @@
 /**
  * Media Generation Hook
  * Hook for generating media with AI
+ * Now a thin wrapper around useGenericMediaGeneration
  */
 
-import { useState, useCallback } from "react";
+import { useGenericMediaGeneration } from "../../infrastructure/hooks/useGenericMediaGeneration";
 import type { UseMediaGenerationResult } from "./multimedia.types";
 import type {
   MediaAttachment,
   MediaGenerationRequest,
-  MediaGenerationResult,
-} from "../../domain/entities/MultimediaFlashcardTypes";
+} from "../../domain/entities/MediaAttachments";
 
 export const useMediaGeneration = (): UseMediaGenerationResult => {
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [generationResult, setGenerationResult] =
-    useState<MediaGenerationResult | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  const generateMedia = useCallback(
-    async (request: MediaGenerationRequest): Promise<MediaGenerationResult> => {
-      try {
-        setIsGenerating(true);
-        setError(null);
-
-        // Simulate generation
-        await new Promise((resolve) => setTimeout(resolve, 3000));
-
-        const attachments: MediaAttachment[] = [];
-
-        switch (request.type) {
-          case "text_to_image":
-            for (let i = 0; i < (request.options.maxResults || 1); i++) {
-              attachments.push({
-                id: `ai_img_${Date.now()}_${i}`,
-                type: "image",
-                position: "both",
-                url: `https://picsum.photos/400/300?random=${Date.now() + i}`,
-                filename: `ai_generated_${i}.jpg`,
-                fileSize: 150000, // 150KB
-                mimeType: "image/jpeg",
-                isDownloaded: false,
-                createdAt: new Date().toISOString(),
-              });
-            }
-            break;
-
-          case "text_to_audio":
-            attachments.push({
-              id: `ai_audio_${Date.now()}`,
-              type: "audio",
-              position: "back",
-              url: `https://example.com/audio_${Date.now()}.mp3`,
-              filename: `ai_generated_${Date.now()}.mp3`,
-              fileSize: 80000, // 80KB
-              mimeType: "audio/mp3",
-              duration: 10, // 10 seconds
-              isDownloaded: false,
-              createdAt: new Date().toISOString(),
-            });
-            break;
-        }
-
-        const result: MediaGenerationResult = {
-          success: true,
-          attachments,
-          creditsUsed: request.type === "text_to_image" ? 5 : 3,
-          processingTime: 3000,
-          requestId: `req_${Date.now()}`,
-        };
-
-        setGenerationResult(result);
-        return result;
-      } catch (err) {
-        const errorMessage =
-          err instanceof Error ? err.message : "Generation failed";
-        setError(errorMessage);
-        setIsGenerating(false);
-
-        return {
-          success: false,
-          attachments: [],
-          creditsUsed: 0,
-          processingTime: 0,
-          error: errorMessage,
-          requestId: "",
-        };
-      } finally {
-        setIsGenerating(false);
-      }
-    },
-    [],
+  return useGenericMediaGeneration<MediaAttachment, MediaGenerationRequest>(
+    (baseAttachment) => baseAttachment as MediaAttachment
   );
-
-  return {
-    generateMedia,
-    isGenerating,
-    generationResult,
-    error,
-  };
 };

package/src/media/presentation/hooks/useMediaUpload.ts

@@ -12,7 +12,7 @@ import type {
   MediaCompressionOptions,
   MediaFile,
   MediaUploadProgress,
-} from "../../domain/entities/MultimediaFlashcardTypes";
+} from "../../domain/entities/MediaAttachments";
 
 export const useMediaUpload = (): UseMediaUploadResult => {
   const [isUploading, setIsUploading] = useState(false);