@umituz/react-native-design-system 2.9.40 → 2.9.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "2.9.40",
+  "version": "2.9.42",
   "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/media/index.ts

@@ -44,15 +44,44 @@ export type { SaveResult, SaveOptions } from "./infrastructure/services/MediaSav
 // Presentation Layer - Original Media Hooks
 export { useMedia } from "./presentation/hooks/useMedia";
 
-// Media Helper Utilities
+// URL Media Detection
 export {
   getMediaTypeFromUrl,
   isVideoUrl,
   isImageUrl,
-  getMediaType,
-  getCardMediaType,
+  isAudioUrl,
+  type UrlMediaType,
+} from "./infrastructure/utils/url-media-detector";
+
+// MIME Type Detection
+export {
+  getMediaTypeFromMime,
+  isVideoMime,
+  isImageMime,
+  isAudioMime,
+  type MimeMediaType,
+} from "./infrastructure/utils/mime-type-detector";
+
+// Media URL Extraction
+export {
+  extractMediaUrl,
+  extractVideoUrl,
+  extractImageUrl,
+  type MediaUrlResult,
+} from "./infrastructure/utils/media-url-extractor";
+
+// Media Collection Utilities
+export {
+  extractMediaTypes,
+  calculateTotalSize,
   formatFileSize,
-} from "./infrastructure/utils/mediaHelpers";
+} from "./infrastructure/utils/media-collection-utils";
+
+// File Media Utilities
+export {
+  getMediaDuration,
+  generateThumbnail,
+} from "./infrastructure/utils/file-media-utils";
 
 // Multimedia Flashcard Support
 export type {

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

@@ -9,11 +9,8 @@ import type {
   CardMediaAttachment,
   CardMediaCompressionOptions,
 } from "../../domain/entities/CardMultimedia.types";
-import {
-  generateThumbnail,
-  getCardMediaType,
-  getMediaDuration,
-} from "../utils/mediaHelpers";
+import { generateThumbnail, getMediaDuration } from "../utils/file-media-utils";
+import { getMediaTypeFromMime } from "../utils/mime-type-detector";
 
 export class CardMediaUploadService {
   /**
@@ -29,7 +26,7 @@ export class CardMediaUploadService {
 
       const attachment: CardMediaAttachment = {
         id: `card_media_${Date.now()}`,
-        type: getCardMediaType(file.type),
+        type: getMediaTypeFromMime(file.type),
         position: "both",
         url: `https://storage.example.com/media/${Date.now()}_${file.name}`,
         filename: file.name,

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

@@ -7,11 +7,8 @@ import type {
   MediaAttachment,
   MediaCompressionOptions,
 } from "../../domain/entities/MultimediaFlashcardTypes";
-import {
-  generateThumbnail,
-  getMediaDuration,
-  getMediaType,
-} from "../utils/mediaHelpers";
+import { generateThumbnail, getMediaDuration } from "../utils/file-media-utils";
+import { getMediaTypeFromMime } from "../utils/mime-type-detector";
 
 export class MediaUploadService {
   /**
@@ -27,7 +24,7 @@ export class MediaUploadService {
 
       const attachment: MediaAttachment = {
         id: `media_${Date.now()}`,
-        type: getMediaType(file.type),
+        type: getMediaTypeFromMime(file.type),
         position: "both",
         url: `https://storage.example.com/media/${Date.now()}_${file.name}`,
         filename: file.name,

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

@@ -0,0 +1,17 @@
+interface FileWithType {
+  readonly type: string;
+}
+
+export async function getMediaDuration(file: FileWithType): Promise<number | undefined> {
+  if (file.type.startsWith("audio/") || file.type.startsWith("video/")) {
+    return Math.floor(Math.random() * 60) + 10;
+  }
+  return undefined;
+}
+
+export function generateThumbnail(file: FileWithType): string | undefined {
+  if (file.type.startsWith("video/")) {
+    return `https://picsum.photos/200/150?random=${Date.now()}`;
+  }
+  return undefined;
+}

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

@@ -0,0 +1,27 @@
+import type { CardMediaAttachment } from "../../domain/entities/CardMultimedia.types";
+import type { MediaAttachment } from "../../domain/entities/MultimediaFlashcardTypes";
+
+type MediaType = "image" | "audio" | "video";
+
+const FILE_SIZE_UNITS = ["Bytes", "KB", "MB", "GB"] as const;
+
+export function extractMediaTypes(
+  media: readonly (CardMediaAttachment | MediaAttachment)[]
+): MediaType[] {
+  const types = new Set<MediaType>();
+  media.forEach((m) => types.add(m.type));
+  return Array.from(types);
+}
+
+export function calculateTotalSize(
+  media: readonly (CardMediaAttachment | MediaAttachment)[]
+): number {
+  return media.reduce((total, m) => total + m.fileSize, 0);
+}
+
+export function formatFileSize(bytes: number): string {
+  if (bytes === 0) return "0 Bytes";
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const size = Math.round((bytes / Math.pow(1024, i)) * 100) / 100;
+  return `${size} ${FILE_SIZE_UNITS[i]}`;
+}

package/src/media/infrastructure/utils/media-url-extractor.ts

@@ -0,0 +1,50 @@
+export interface MediaUrlResult {
+  readonly url: string;
+  readonly isVideo: boolean;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function findStringValue(obj: Record<string, unknown>, keys: readonly string[]): string | undefined {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return undefined;
+}
+
+const VIDEO_URL_KEYS = ["videoUrl", "video_url", "videoURL"] as const;
+const IMAGE_URL_KEYS = ["imageUrl", "image_url", "imageURL", "uri", "url"] as const;
+
+export function extractMediaUrl(result: unknown): MediaUrlResult | null {
+  if (!isRecord(result)) return null;
+
+  const output = isRecord(result.output) ? result.output : undefined;
+  const sources = output ? [output, result] : [result];
+
+  for (const source of sources) {
+    const videoUrl = findStringValue(source, VIDEO_URL_KEYS);
+    if (videoUrl) return { url: videoUrl, isVideo: true };
+  }
+
+  for (const source of sources) {
+    const imageUrl = findStringValue(source, IMAGE_URL_KEYS);
+    if (imageUrl) return { url: imageUrl, isVideo: false };
+  }
+
+  return null;
+}
+
+export function extractVideoUrl(result: unknown): string | null {
+  const media = extractMediaUrl(result);
+  if (media?.isVideo) return media.url;
+  return null;
+}
+
+export function extractImageUrl(result: unknown): string | null {
+  const media = extractMediaUrl(result);
+  if (media && !media.isVideo) return media.url;
+  return null;
+}

package/src/media/infrastructure/utils/mime-type-detector.ts

@@ -0,0 +1,20 @@
+export type MimeMediaType = "image" | "audio" | "video";
+
+export function getMediaTypeFromMime(mimeType: string): MimeMediaType {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("audio/")) return "audio";
+  if (mimeType.startsWith("video/")) return "video";
+  return "image";
+}
+
+export function isVideoMime(mimeType: string): boolean {
+  return mimeType.startsWith("video/");
+}
+
+export function isImageMime(mimeType: string): boolean {
+  return mimeType.startsWith("image/");
+}
+
+export function isAudioMime(mimeType: string): boolean {
+  return mimeType.startsWith("audio/");
+}

package/src/media/infrastructure/utils/url-media-detector.ts

@@ -0,0 +1,34 @@
+export type UrlMediaType = "image" | "video" | "audio" | "unknown";
+
+const VIDEO_EXTENSIONS = [".mp4", ".webm", ".mov", ".avi", ".mkv", ".m4v"];
+const IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg"];
+const AUDIO_EXTENSIONS = [".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac"];
+
+function getExtensionFromUrl(url: string): string | null {
+  if (!url) return null;
+  const urlWithoutParams = url.toLowerCase().split("?")[0];
+  const lastDotIndex = urlWithoutParams.lastIndexOf(".");
+  if (lastDotIndex === -1) return null;
+  return urlWithoutParams.substring(lastDotIndex);
+}
+
+export function getMediaTypeFromUrl(url: string): UrlMediaType {
+  const extension = getExtensionFromUrl(url);
+  if (!extension) return "unknown";
+  if (VIDEO_EXTENSIONS.includes(extension)) return "video";
+  if (IMAGE_EXTENSIONS.includes(extension)) return "image";
+  if (AUDIO_EXTENSIONS.includes(extension)) return "audio";
+  return "unknown";
+}
+
+export function isVideoUrl(url: string): boolean {
+  return getMediaTypeFromUrl(url) === "video";
+}
+
+export function isImageUrl(url: string): boolean {
+  return getMediaTypeFromUrl(url) === "image";
+}
+
+export function isAudioUrl(url: string): boolean {
+  return getMediaTypeFromUrl(url) === "audio";
+}

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

@@ -4,11 +4,8 @@
  */
 
 import React from "react";
-import {
-  generateThumbnail,
-  getCardMediaType,
-  getMediaDuration,
-} from "../../infrastructure/utils/mediaHelpers";
+import { generateThumbnail, getMediaDuration } from "../../infrastructure/utils/file-media-utils";
+import { getMediaTypeFromMime } from "../../infrastructure/utils/mime-type-detector";
 import type { UseCardMediaUploadResult } from "./card-multimedia.types";
 import type {
   CardMediaAttachment,
@@ -43,7 +40,7 @@ export const useCardMediaUpload = (): UseCardMediaUploadResult => {
 
         const attachment: CardMediaAttachment = {
           id: `card_media_${Date.now()}`,
-          type: getCardMediaType(file.type),
+          type: getMediaTypeFromMime(file.type),
           position: "both",
           url: `https://storage.example.com/media/${Date.now()}_${file.name}`,
           filename: file.name,

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

@@ -4,11 +4,8 @@
  */
 
 import React from "react";
-import {
-  generateThumbnail,
-  getMediaDuration,
-  getMediaType,
-} from "../../infrastructure/utils/mediaHelpers";
+import { generateThumbnail, getMediaDuration } from "../../infrastructure/utils/file-media-utils";
+import { getMediaTypeFromMime } from "../../infrastructure/utils/mime-type-detector";
 import type { UseMediaUploadResult } from "./multimedia.types";
 import type {
   MediaAttachment,
@@ -43,7 +40,7 @@ export const useMediaUpload = (): UseMediaUploadResult => {
 
         const attachment: MediaAttachment = {
           id: `media_${Date.now()}`,
-          type: getMediaType(file.type),
+          type: getMediaTypeFromMime(file.type),
           position: "both",
           url: `https://storage.example.com/media/${Date.now()}_${file.name}`,
           filename: file.name,

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

@@ -1,126 +0,0 @@
-/**
- * Media Helper Utilities
- * Shared helper functions for media operations
- */
-
-import type {
-  CardMediaAttachment,
-  CardMediaType,
-} from "../../domain/entities/CardMultimedia.types";
-import type { MediaAttachment } from "../../domain/entities/MultimediaFlashcardTypes";
-
-/**
- * Get media type from MIME type for CardMedia
- */
-export const getCardMediaType = (mimeType: string): CardMediaType => {
-  if (mimeType.startsWith("image/")) return "image";
-  if (mimeType.startsWith("audio/")) return "audio";
-  if (mimeType.startsWith("video/")) return "video";
-  return "image";
-};
-
-/**
- * Get media type from MIME type for Media
- */
-export const getMediaType = (mimeType: string): "image" | "audio" | "video" => {
-  if (mimeType.startsWith("image/")) return "image";
-  if (mimeType.startsWith("audio/")) return "audio";
-  if (mimeType.startsWith("video/")) return "video";
-  return "image";
-};
-
-/**
- * Get media duration for audio/video files
- */
-export const getMediaDuration = async (
-  file: any
-): Promise<number | undefined> => {
-  if (file.type.startsWith("audio/") || file.type.startsWith("video/")) {
-    return Math.floor(Math.random() * 60) + 10;
-  }
-  return undefined;
-};
-
-/**
- * Generate thumbnail URL for video files
- */
-export const generateThumbnail = (file: any): string | undefined => {
-  if (file.type.startsWith("video/")) {
-    return `https://picsum.photos/200/150?random=${Date.now()}`;
-  }
-  return undefined;
-};
-
-/**
- * Extract unique media types from attachments
- */
-export const extractMediaTypes = (
-  media: CardMediaAttachment[] | MediaAttachment[]
-): ("image" | "audio" | "video")[] => {
-  const types: Set<string> = new Set();
-  media.forEach((m) => types.add(m.type));
-  return Array.from(types) as ("image" | "audio" | "video")[];
-};
-
-/**
- * Calculate total file size of media attachments
- */
-export const calculateTotalSize = (
-  media: CardMediaAttachment[] | MediaAttachment[]
-): number => {
-  return media.reduce((total, m) => total + m.fileSize, 0);
-};
-
-/**
- * Format bytes to human-readable file size
- */
-export const formatFileSize = (bytes: number): string => {
-  const sizes = ["Bytes", "KB", "MB", "GB"];
-  if (bytes === 0) return "0 Bytes";
-  const i = Math.floor(Math.log(bytes) / Math.log(1024));
-  return Math.round((bytes / Math.pow(1024, i)) * 100) / 100 + " " + sizes[i];
-};
-
-// URL-based media type detection constants
-const VIDEO_EXTENSIONS = [".mp4", ".webm", ".mov", ".avi", ".mkv", ".m4v"];
-const IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg"];
-const AUDIO_EXTENSIONS = [".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac"];
-
-/**
- * Get media type from URL based on file extension
- */
-export const getMediaTypeFromUrl = (
-  url: string
-): "image" | "video" | "audio" | "unknown" => {
-  if (!url) return "unknown";
-
-  const lowercaseUrl = url.toLowerCase();
-
-  // Extract extension (handle query params)
-  const urlWithoutParams = lowercaseUrl.split("?")[0];
-  const lastDotIndex = urlWithoutParams.lastIndexOf(".");
-  if (lastDotIndex === -1) return "unknown";
-
-  const extension = urlWithoutParams.substring(lastDotIndex);
-
-  if (VIDEO_EXTENSIONS.includes(extension)) return "video";
-  if (IMAGE_EXTENSIONS.includes(extension)) return "image";
-  if (AUDIO_EXTENSIONS.includes(extension)) return "audio";
-
-  return "unknown";
-};
-
-/**
- * Check if URL points to a video file
- */
-export const isVideoUrl = (url: string): boolean => {
-  return getMediaTypeFromUrl(url) === "video";
-};
-
-/**
- * Check if URL points to an image file
- */
-export const isImageUrl = (url: string): boolean => {
-  const mediaType = getMediaTypeFromUrl(url);
-  return mediaType === "image" || mediaType === "unknown";
-};