@uploadista/react-native-bare 0.0.20-beta.6 → 0.0.20-beta.8

package/package.json

@@ -2,30 +2,45 @@
   "name": "@uploadista/react-native-bare",
   "type": "module",
   "description": "Bare React Native Client for Uploadista",
-  "version": "0.0.20-beta.6",
+  "version": "0.0.20-beta.8",
   "license": "MIT",
   "author": "Uploadista",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@uploadista/client-core": "0.0.20-beta.6",
-    "@uploadista/react-native-core": "0.0.20-beta.6"
+    "@uploadista/client-core": "0.0.20-beta.8",
+    "@uploadista/react-native-core": "0.0.20-beta.8"
   },
   "peerDependencies": {
+    "js-base64": ">=3.7.0",
+    "uuid": ">=13.0.0",
     "react": ">=16.8.0",
     "react-native": ">=0.71.0",
     "@react-native-documents/picker": ">=10.0.0",
     "react-native-image-picker": ">=7.0.0",
-    "rn-fetch-blob": ">=0.12.0"
+    "react-native-quick-crypto": ">=0.7.0",
+    "rn-fetch-blob": ">=0.12.0",
+    "@react-native-async-storage/async-storage": ">=1.19.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-documents/picker": {
+      "optional": true
+    },
+    "react-native-image-picker": {
+      "optional": true
+    },
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/react": ">=18.0.0",
-    "tsdown": "0.17.2",
-    "@uploadista/typescript-config": "0.0.20-beta.6"
+    "tsdown": "0.18.0",
+    "@uploadista/typescript-config": "0.0.20-beta.8"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsc --noEmit && tsdown",
     "format": "biome format --write ./src",
     "lint": "biome lint --write ./src",
     "check": "biome check --write ./src"

package/src/services/checksum-service.ts

@@ -0,0 +1,14 @@
+import type { ChecksumService } from "@uploadista/client-core";
+import { computeUint8ArraySha256 } from "../utils/hash-util";
+
+/**
+ * Creates a ChecksumService for Expo environments
+ * Computes SHA-256 checksums of file data using Web Crypto API
+ */
+export function createReactNativeChecksumService(): ChecksumService {
+  return {
+    computeChecksum: async (data: Uint8Array<ArrayBuffer>) => {
+      return computeUint8ArraySha256(data);
+    },
+  };
+}

package/src/services/create-react-native-services.ts

@@ -3,12 +3,15 @@ import {
   createInMemoryStorageService,
   type ServiceContainer,
 } from "@uploadista/client-core";
-import type { ReactNativeUploadInput } from "@/types/upload-input";
+import type { ReactNativeUploadInput } from "@uploadista/react-native-core";
 import { createReactNativeAbortControllerFactory } from "./abort-controller-factory";
 import { createReactNativeBase64Service } from "./base64-service";
+import { createReactNativeChecksumService } from "./checksum-service";
 import { createReactNativeFileReaderService } from "./file-reader-service";
+import { createReactNativeFingerprintService } from "./fingerprint-service";
 import { createReactNativeHttpClient } from "./http-client";
 import { createReactNativeIdGenerationService } from "./id-generation-service";
+import { createReactNativePlatformService } from "./platform-service";
 import { createAsyncStorageService } from "./storage-service";
 import { createReactNativeWebSocketFactory } from "./websocket-factory";
 
@@ -63,6 +66,9 @@ export function createReactNativeServices(
   const base64 = createReactNativeBase64Service();
   const websocket = createReactNativeWebSocketFactory();
   const abortController = createReactNativeAbortControllerFactory();
+  const platform = createReactNativePlatformService();
+  const checksumService = createReactNativeChecksumService();
+  const fingerprintService = createReactNativeFingerprintService();
 
   return {
     storage,
@@ -70,6 +76,9 @@ export function createReactNativeServices(
     httpClient,
     fileReader,
     base64,
+    platform,
+    checksumService,
+    fingerprintService,
     websocket,
     abortController,
   };

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

@@ -3,7 +3,7 @@ import type {
   FileSource,
   SliceResult,
 } from "@uploadista/client-core";
-import type { ReactNativeUploadInput } from "@/types/upload-input";
+import type { ReactNativeUploadInput } from "@uploadista/react-native-core";
 
 /**
  * React Native-specific implementation of FileReaderService

package/src/services/fingerprint-service.ts

@@ -0,0 +1,114 @@
+import type { FingerprintService } from "@uploadista/client-core";
+import type { ReactNativeUploadInput } from "@uploadista/react-native-core";
+import { createHash } from "react-native-quick-crypto";
+import { computeblobSha256 } from "../utils/hash-util";
+
+/**
+ * Creates a FingerprintService for bare React Native environments
+ * Computes file fingerprints using SHA-256 hashing
+ * Supports Blob, File, and URI-based inputs
+ */
+export function createReactNativeFingerprintService(): FingerprintService<ReactNativeUploadInput> {
+  return {
+    computeFingerprint: async (input, _endpoint) => {
+      // Handle Blob/File objects directly
+      if (input instanceof Blob) {
+        return computeblobSha256(input);
+      }
+
+      // For URI inputs (string or {uri: string}), we need to convert to Blob first
+      if (
+        typeof input === "string" ||
+        (input && typeof input === "object" && "uri" in input)
+      ) {
+        const uri =
+          typeof input === "string" ? input : (input as { uri: string }).uri;
+        return computeFingerprintFromUri(uri);
+      }
+
+      throw new Error(
+        "Unsupported file input type for fingerprinting. Expected Blob, File, URI string, or {uri: string}",
+      );
+    },
+  };
+}
+
+/**
+ * Compute fingerprint from a file URI
+ * Uses rn-fetch-blob to read the file and compute its SHA-256 hash
+ */
+async function computeFingerprintFromUri(uri: string): Promise<string> {
+  try {
+    // Use rn-fetch-blob to read the file as base64
+    const RNFetchBlob = getRNFetchBlob();
+
+    // Normalize URI path for rn-fetch-blob
+    const normalizedPath = normalizeUri(uri);
+
+    // Check if file exists
+    const exists = await RNFetchBlob.fs.exists(normalizedPath);
+    if (!exists) {
+      throw new Error(`File does not exist at URI: ${uri}`);
+    }
+
+    // Read the entire file as base64
+    const base64String = await RNFetchBlob.fs.readFile(normalizedPath, "base64");
+
+    // Convert base64 to Uint8Array
+    const uint8Array = base64ToUint8Array(base64String);
+
+    // Compute SHA-256 hash using react-native-quick-crypto
+    const hash = createHash("sha256");
+    hash.update(uint8Array);
+    return hash.digest("hex");
+  } catch (error) {
+    throw new Error(
+      `Failed to compute fingerprint from URI ${uri}: ${error instanceof Error ? error.message : "Unknown error"}`,
+    );
+  }
+}
+
+/**
+ * Normalize URI for rn-fetch-blob
+ * Strips file:// prefix and handles platform-specific paths
+ */
+function normalizeUri(uri: string): string {
+  // Remove file:// prefix if present
+  if (uri.startsWith("file://")) {
+    return uri.substring(7);
+  }
+  return uri;
+}
+
+/**
+ * Get rn-fetch-blob module
+ * This allows the service to work even if rn-fetch-blob is not installed
+ */
+function getRNFetchBlob() {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require("rn-fetch-blob").default;
+  } catch (_error) {
+    throw new Error(
+      "rn-fetch-blob is required for URI-based fingerprinting. " +
+        "Please install it with: npm install rn-fetch-blob",
+    );
+  }
+}
+
+/**
+ * Convert base64 string to Uint8Array
+ * Uses js-base64 library for cross-platform compatibility
+ */
+function base64ToUint8Array(base64: string): Uint8Array {
+  // Use js-base64 for decoding (works in all environments)
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { fromBase64 } = require("js-base64");
+  const binaryString = fromBase64(base64);
+
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}

package/src/services/storage-service.ts

@@ -1,17 +1,35 @@
-import AsyncStorage from "@react-native-async-storage/async-storage";
 import type { StorageService } from "@uploadista/client-core";
+
+/**
+ * Get AsyncStorage module dynamically
+ * This allows the service to work even if AsyncStorage is not installed
+ */
+function getAsyncStorage() {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require("@react-native-async-storage/async-storage").default;
+  } catch (_error) {
+    throw new Error(
+      "@react-native-async-storage/async-storage is required for persistent storage. " +
+        "Please install it with: npm install @react-native-async-storage/async-storage",
+    );
+  }
+}
+
 /**
- * Expo-specific implementation of StorageService using AsyncStorage
+ * React Native-specific implementation of StorageService using AsyncStorage
  * AsyncStorage is provided as an optional peer dependency and must be installed separately
  */
 export function createAsyncStorageService(): StorageService {
+  const AsyncStorage = getAsyncStorage();
+
   const findEntries = async (
     prefix: string,
   ): Promise<Record<string, string>> => {
     const results: Record<string, string> = {};
 
     const keys = await AsyncStorage.getAllKeys();
-    for (const key in keys) {
+    for (const key of keys) {
       if (key.startsWith(prefix)) {
         const item = await AsyncStorage.getItem(key);
         if (item) {

package/src/services/websocket-factory.ts

@@ -10,35 +10,42 @@ class ReactNativeWebSocket implements WebSocketLike {
   readonly CLOSING = 2;
   readonly CLOSED = 3;
 
-  readonly readyState: number;
-  onopen: ((event: unknown) => void) | null = null;
-  onclose: ((event: unknown) => void) | null = null;
-  onerror: ((event: unknown) => void) | null = null;
-  onmessage: ((event: unknown) => void) | null = null;
+  onopen: (() => void) | null = null;
+  onclose: ((event: { code: number; reason: string }) => void) | null = null;
+  onerror: ((event: { message: string }) => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
 
   private native: WebSocket;
 
+  get readyState(): number {
+    return this.native.readyState;
+  }
+
   constructor(url: string) {
     this.native = new WebSocket(url);
-    this.readyState = this.native.readyState;
 
     // Proxy event handlers
-    this.native.onopen = (event) => {
-      this.readyState = this.native.readyState;
-      this.onopen?.(event);
+    this.native.onopen = () => {
+      this.onopen?.();
     };
 
     this.native.onclose = (event) => {
-      this.readyState = this.native.readyState;
-      this.onclose?.(event);
+      this.onclose?.({
+        code: (event as CloseEvent).code ?? 1000,
+        reason: (event as CloseEvent).reason ?? "",
+      });
     };
 
     this.native.onerror = (event) => {
-      this.onerror?.(event);
+      this.onerror?.({
+        message: (event as ErrorEvent).message ?? "WebSocket error",
+      });
     };
 
     this.native.onmessage = (event) => {
-      this.onmessage?.(event);
+      this.onmessage?.({
+        data: (event as MessageEvent).data as string,
+      });
     };
   }
 

package/src/utils/hash-util.ts

@@ -0,0 +1,60 @@
+import { createHash } from "react-native-quick-crypto";
+
+/**
+ * Compute SHA-256 checksum using Node.js crypto API
+ * Compatible with bare React Native environments via react-native-quick-crypto polyfill
+ *
+ * @param data - Uint8Array to hash
+ * @returns Promise that resolves to hex-encoded SHA-256 checksum
+ */
+export async function computeUint8ArraySha256(
+  data: Uint8Array,
+): Promise<string> {
+  try {
+    const hash = createHash("sha256");
+    hash.update(data);
+    return hash.digest("hex");
+  } catch (error) {
+    throw new Error(
+      `Failed to compute checksum: ${error instanceof Error ? error.message : "Unknown error"}`,
+    );
+  }
+}
+
+/**
+ * Compute SHA-256 checksum of a Blob using Node.js crypto API
+ * Compatible with bare React Native environments via react-native-quick-crypto polyfill
+ *
+ * @param blob - Blob to hash
+ * @returns Promise that resolves to hex-encoded SHA-256 checksum
+ */
+export async function computeblobSha256(blob: Blob): Promise<string> {
+  try {
+    // Convert Blob to Uint8Array using FileReader for compatibility
+    const uint8Array = await blobToUint8Array(blob);
+    return computeUint8ArraySha256(uint8Array);
+  } catch (error) {
+    throw new Error(
+      `Failed to compute file checksum: ${error instanceof Error ? error.message : "Unknown error"}`,
+    );
+  }
+}
+
+/**
+ * Convert Blob to Uint8Array using FileReader
+ * Works in React Native environments
+ */
+async function blobToUint8Array(blob: Blob): Promise<Uint8Array> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      if (reader.result instanceof ArrayBuffer) {
+        resolve(new Uint8Array(reader.result));
+      } else {
+        reject(new Error("FileReader result is not an ArrayBuffer"));
+      }
+    };
+    reader.onerror = () => reject(reader.error);
+    reader.readAsArrayBuffer(blob);
+  });
+}