@umituz/react-native-design-system 2.9.47 → 2.9.49

package/package.json

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

@@ -22,5 +22,12 @@ export { clearCache } from "./infrastructure/services/cache.service";
 // Services - File Reading
 export { readFile, readFileAsBase64 } from "./infrastructure/services/file-reader.service";
 
-// Utils - Blob Operations
-export { blobToBase64, base64ToBlob, base64ToFile } from "./infrastructure/utils/blob.utils";
+// Utils - Base64 and File Operations
+export {
+  extractBase64FromDataUri,
+  detectMimeType,
+  getExtensionFromMimeType,
+  base64ToTempFile,
+  deleteTempFile,
+  getFileSize,
+} from "./infrastructure/utils/blob.utils";

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

@@ -1,28 +1,14 @@
 /**
  * Blob Utils
- * Blob utility functions for file operations
+ * Base64 and file utility functions for React Native
  */
 
-/**
- * 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);
-  });
-}
+import { File, Paths } from "expo-file-system";
 
 /**
  * Extract raw base64 from data URI
  */
-function extractBase64FromDataUri(dataUri: string): string {
+export function extractBase64FromDataUri(dataUri: string): string {
   if (!dataUri.startsWith("data:")) {
     return dataUri;
   }
@@ -31,9 +17,9 @@ function extractBase64FromDataUri(dataUri: string): string {
 }
 
 /**
- * Detect MIME type from data URI
+ * Detect MIME type from data URI or base64
  */
-function detectMimeType(base64: string): string {
+export function detectMimeType(base64: string): string {
   if (base64.includes("data:image/png")) return "image/png";
   if (base64.includes("data:image/webp")) return "image/webp";
   if (base64.includes("data:image/gif")) return "image/gif";
@@ -41,29 +27,72 @@ function detectMimeType(base64: string): string {
 }
 
 /**
- * Convert base64 string to Blob
+ * Get file extension from MIME type
  */
-export function base64ToBlob(base64: string, mimeType?: string): Blob {
-  const detectedMime = mimeType ?? detectMimeType(base64);
-  const cleanBase64 = extractBase64FromDataUri(base64);
-  const byteCharacters = atob(cleanBase64);
-  const byteArray = new Uint8Array(byteCharacters.length);
+export function getExtensionFromMimeType(mimeType: string): string {
+  const ext = mimeType.split("/")[1];
+  if (ext === "jpeg") return "jpg";
+  return ext ?? "jpg";
+}
 
-  for (let i = 0; i < byteCharacters.length; i++) {
-    byteArray[i] = byteCharacters.charCodeAt(i);
+/**
+ * Convert base64 string to Uint8Array
+ * Required for binary file writing in new expo-file-system API
+ */
+function base64ToUint8Array(base64: string): Uint8Array {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
   }
-
-  return new Blob([byteArray.buffer], { type: detectedMime });
+  return bytes;
 }
 
 /**
- * Convert base64 string to File
+ * Write base64 to a temp file and return the file URI
+ * This is React Native compatible (no Blob/ArrayBuffer needed)
  */
-export function base64ToFile(base64: string, filename?: string): File {
+export async function base64ToTempFile(
+  base64: string,
+  filename?: string,
+): Promise<string> {
   const mimeType = detectMimeType(base64);
-  const extension = mimeType.split("/")[1] ?? "jpg";
-  const name = filename ?? `image.${extension}`;
-  const blob = base64ToBlob(base64, mimeType);
+  const extension = getExtensionFromMimeType(mimeType);
+  const cleanBase64 = extractBase64FromDataUri(base64);
+  const name = filename ?? `temp_${Date.now()}.${extension}`;
+
+  const file = new File(Paths.cache, name);
+  await file.create();
+
+  // Convert base64 to Uint8Array for binary writing
+  const binaryData = base64ToUint8Array(cleanBase64);
+  file.write(binaryData);
 
-  return new File([blob], name, { type: mimeType });
+  return file.uri;
+}
+
+/**
+ * Delete a temp file
+ */
+export async function deleteTempFile(uri: string): Promise<void> {
+  try {
+    const file = new File(uri);
+    if (file.exists) {
+      file.delete();
+    }
+  } catch {
+    // Ignore deletion errors
+  }
+}
+
+/**
+ * Get file size from URI
+ */
+export function getFileSize(uri: string): number {
+  try {
+    const file = new File(uri);
+    return file.exists ? (file.size ?? 0) : 0;
+  } catch {
+    return 0;
+  }
 }