@uploadista/react-native-bare 0.0.3

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

@@ -0,0 +1,144 @@
+import type {
+  FileReaderService,
+  FileSource,
+  SliceResult,
+} from "@uploadista/client-core";
+import type { ReactNativeUploadInput } from "@/types/upload-input";
+
+/**
+ * React Native-specific implementation of FileReaderService
+ * Handles Blob, File, and URI-based file inputs
+ */
+export function createReactNativeFileReaderService(): FileReaderService<ReactNativeUploadInput> {
+  return {
+    async openFile(input, _chunkSize: number): Promise<FileSource> {
+      // Handle Blob/File objects
+      if (input instanceof Blob) {
+        return createBlobFileSource(input);
+      }
+
+      // Handle URI strings or URI objects
+      if (
+        typeof input === "string" ||
+        (input && typeof input === "object" && "uri" in input)
+      ) {
+        const uri =
+          typeof input === "string" ? input : (input as { uri: string }).uri;
+        return createUriFileSource(uri);
+      }
+
+      throw new Error(
+        "Unsupported file input type for React Native. Expected Blob, File, URI string, or {uri: string}",
+      );
+    },
+  };
+}
+
+/**
+ * Create a FileSource from a Blob object
+ */
+function createBlobFileSource(blob: Blob): FileSource {
+  return {
+    input: blob,
+    size: blob.size,
+    async slice(start: number, end: number): Promise<SliceResult> {
+      const chunk = blob.slice(start, end);
+
+      // React Native Blob may not have arrayBuffer() method
+      let arrayBuffer: ArrayBuffer;
+      if (typeof chunk.arrayBuffer === "function") {
+        arrayBuffer = await chunk.arrayBuffer();
+      } else {
+        // Fallback: use FileReader for React Native
+        arrayBuffer = await blobToArrayBuffer(chunk);
+      }
+
+      const done = end >= blob.size;
+
+      return {
+        done,
+        value: new Uint8Array(arrayBuffer),
+        size: chunk.size,
+      };
+    },
+    close() {
+      // No cleanup needed for Blob
+    },
+    name: null,
+    type: null,
+    lastModified: null,
+  };
+}
+
+/**
+ * Convert Blob to ArrayBuffer using FileReader (fallback for React Native)
+ */
+function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      if (reader.result instanceof ArrayBuffer) {
+        resolve(reader.result);
+      } else {
+        reject(new Error("FileReader result is not an ArrayBuffer"));
+      }
+    };
+    reader.onerror = () => reject(reader.error);
+    reader.readAsArrayBuffer(blob);
+  });
+}
+
+/**
+ * Create a FileSource from a URI
+ * This is a simplified implementation - you may need to use react-native-fs
+ * or another library for more advanced file operations
+ */
+function createUriFileSource(uri: string): FileSource {
+  // For URIs, we need to fetch the file first
+  // This implementation assumes the URI can be fetched as a blob
+  let cachedBlob: Blob | null = null;
+  let cachedSize: number | null = null;
+
+  return {
+    input: uri,
+    size: cachedSize,
+    async slice(start: number, end: number): Promise<SliceResult> {
+      // Fetch the blob if not cached
+      if (!cachedBlob) {
+        try {
+          const response = await fetch(uri);
+          cachedBlob = await response.blob();
+          cachedSize = cachedBlob.size;
+        } catch (error) {
+          throw new Error(`Failed to fetch file from URI ${uri}: ${error}`);
+        }
+      }
+
+      const chunk = cachedBlob.slice(start, end);
+
+      // React Native Blob may not have arrayBuffer() method
+      let arrayBuffer: ArrayBuffer;
+      if (typeof chunk.arrayBuffer === "function") {
+        arrayBuffer = await chunk.arrayBuffer();
+      } else {
+        arrayBuffer = await blobToArrayBuffer(chunk);
+      }
+
+      const done = end >= cachedBlob.size;
+
+      return {
+        done,
+        value: new Uint8Array(arrayBuffer),
+        size: chunk.size,
+      };
+    },
+    close() {
+      // Clear cached blob
+      cachedBlob = null;
+      cachedSize = null;
+    },
+    lastModified: null,
+    name: uri,
+    type: null,
+  };
+}

package/src/services/http-client.ts

@@ -0,0 +1,242 @@
+import type {
+  ConnectionHealth,
+  ConnectionMetrics,
+  ConnectionPoolConfig,
+  DetailedConnectionMetrics,
+  HeadersLike,
+  Http2Info,
+  HttpClient,
+  HttpRequestOptions,
+  HttpResponse,
+} from "@uploadista/client-core";
+
+/**
+ * React Native-specific implementation of HttpClient using fetch API
+ * React Native's fetch is similar to browser fetch but may have different performance characteristics
+ */
+export function createReactNativeHttpClient(
+  config?: ConnectionPoolConfig,
+): HttpClient {
+  return new ReactNativeHttpClient(config);
+}
+
+/**
+ * React Native HTTP client implementation
+ */
+class ReactNativeHttpClient implements HttpClient {
+  private config: ConnectionPoolConfig;
+  private metrics: ConnectionMetrics;
+  private connectionTimes: number[] = [];
+  private requestCount = 0;
+  private connectionCount = 0;
+  private errorCount = 0;
+  private timeoutCount = 0;
+  private retryCount = 0;
+  private startTime = Date.now();
+
+  constructor(config: ConnectionPoolConfig = {}) {
+    this.config = {
+      maxConnectionsPerHost: config.maxConnectionsPerHost ?? 6,
+      connectionTimeout: config.connectionTimeout ?? 30000,
+      keepAliveTimeout: config.keepAliveTimeout ?? 60000,
+      enableHttp2: config.enableHttp2 ?? false, // HTTP/2 not supported in RN
+      retryOnConnectionError: config.retryOnConnectionError ?? true,
+    };
+
+    this.metrics = {
+      activeConnections: 0,
+      totalConnections: 0,
+      reuseRate: 0,
+      averageConnectionTime: 0,
+    };
+  }
+
+  async request(
+    url: string,
+    options: HttpRequestOptions = {},
+  ): Promise<HttpResponse> {
+    this.requestCount++;
+
+    const fetchOptions: RequestInit = {
+      method: options.method || "GET",
+      headers: options.headers,
+      body: options.body as any, // React Native's BodyInit type
+      signal: options.signal as AbortSignal | undefined,
+    };
+
+    // Add credentials if specified
+    if (options.credentials) {
+      fetchOptions.credentials = options.credentials as any; // React Native's RequestCredentials type
+    }
+
+    const startTime = Date.now();
+
+    try {
+      // Handle timeout
+      const timeoutPromise = options.timeout
+        ? new Promise<never>((_, reject) => {
+            setTimeout(() => {
+              this.timeoutCount++;
+              reject(new Error(`Request timeout after ${options.timeout}ms`));
+            }, options.timeout);
+          })
+        : null;
+
+      const fetchPromise = fetch(url, fetchOptions);
+
+      const response = timeoutPromise
+        ? await Promise.race([fetchPromise, timeoutPromise])
+        : await fetchPromise;
+
+      const connectionTime = Date.now() - startTime;
+      this.connectionTimes.push(connectionTime);
+      this.connectionCount++;
+      this.metrics.totalConnections++;
+      this.updateMetrics();
+
+      // Convert fetch Response to HttpResponse
+      return this.adaptResponse(response);
+    } catch (error) {
+      this.errorCount++;
+      throw error;
+    }
+  }
+
+  private adaptResponse(response: Response): HttpResponse {
+    const headers: HeadersLike = {
+      get: (name: string) => response.headers.get(name),
+      has: (name: string) => response.headers.has(name),
+      forEach: (callback: (value: string, name: string) => void) => {
+        response.headers.forEach(callback);
+      },
+    };
+
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      ok: response.ok,
+      json: () => response.json(),
+      text: () => response.text(),
+      arrayBuffer: () => response.arrayBuffer(),
+    };
+  }
+
+  private updateMetrics(): void {
+    if (this.connectionTimes.length > 0) {
+      const sum = this.connectionTimes.reduce((a, b) => a + b, 0);
+      this.metrics.averageConnectionTime = sum / this.connectionTimes.length;
+    }
+
+    // Estimate reuse rate based on connection times
+    // Faster connections are likely reused
+    const fastConnections = this.connectionTimes.filter(
+      (time) => time < 100,
+    ).length;
+    this.metrics.reuseRate =
+      this.connectionTimes.length > 0
+        ? fastConnections / this.connectionTimes.length
+        : 0;
+  }
+
+  getMetrics(): ConnectionMetrics {
+    return { ...this.metrics };
+  }
+
+  getDetailedMetrics(): DetailedConnectionMetrics {
+    const uptime = Date.now() - this.startTime;
+    const requestsPerSecond =
+      uptime > 0 ? this.requestCount / (uptime / 1000) : 0;
+    const errorRate =
+      this.requestCount > 0 ? this.errorCount / this.requestCount : 0;
+
+    const fastConnections = this.connectionTimes.filter(
+      (time) => time < 100,
+    ).length;
+    const slowConnections = this.connectionTimes.length - fastConnections;
+
+    const health = this.calculateHealth(errorRate);
+
+    const http2Info: Http2Info = {
+      supported: false, // React Native doesn't support HTTP/2
+      detected: false,
+      version: "h1.1",
+      multiplexingActive: false,
+    };
+
+    return {
+      ...this.metrics,
+      health,
+      requestsPerSecond,
+      errorRate,
+      timeouts: this.timeoutCount,
+      retries: this.retryCount,
+      fastConnections,
+      slowConnections,
+      http2Info,
+    };
+  }
+
+  private calculateHealth(errorRate: number): ConnectionHealth {
+    let status: "healthy" | "degraded" | "poor";
+    let score: number;
+    const issues: string[] = [];
+    const recommendations: string[] = [];
+
+    if (errorRate > 0.1) {
+      status = "poor";
+      score = 30;
+      issues.push(`High error rate: ${(errorRate * 100).toFixed(1)}%`);
+      recommendations.push("Check network connectivity");
+    } else if (errorRate > 0.05) {
+      status = "degraded";
+      score = 60;
+      issues.push(`Moderate error rate: ${(errorRate * 100).toFixed(1)}%`);
+      recommendations.push("Monitor connection stability");
+    } else {
+      status = "healthy";
+      score = 100;
+    }
+
+    if (this.metrics.averageConnectionTime > 1000) {
+      issues.push(
+        `Slow connections: ${this.metrics.averageConnectionTime.toFixed(0)}ms avg`,
+      );
+      recommendations.push("Check network conditions");
+      score = Math.min(score, 70);
+    }
+
+    return { status, score, issues, recommendations };
+  }
+
+  reset(): void {
+    this.metrics = {
+      activeConnections: 0,
+      totalConnections: 0,
+      reuseRate: 0,
+      averageConnectionTime: 0,
+    };
+    this.connectionTimes = [];
+    this.requestCount = 0;
+    this.connectionCount = 0;
+    this.errorCount = 0;
+    this.timeoutCount = 0;
+    this.retryCount = 0;
+    this.startTime = Date.now();
+  }
+
+  async close(): Promise<void> {
+    // React Native fetch doesn't require explicit connection closing
+    this.reset();
+  }
+
+  async warmupConnections(urls: string[]): Promise<void> {
+    // Warmup by making HEAD requests to the URLs
+    const promises = urls.map((url) =>
+      this.request(url, { method: "HEAD" }).catch(() => {
+        // Ignore warmup errors
+      }),
+    );
+    await Promise.all(promises);
+  }
+}

package/src/services/id-generation-service.ts

@@ -0,0 +1,14 @@
+import type { IdGenerationService } from "@uploadista/client-core";
+import { v4 as uuidv4 } from "uuid";
+
+/**
+ * React Native-specific implementation of IdGenerationService using uuid library
+ * crypto.randomUUID() is not available in React Native, so we use the uuid library
+ */
+export function createReactNativeIdGenerationService(): IdGenerationService {
+  return {
+    generate(): string {
+      return uuidv4();
+    },
+  };
+}

package/src/services/index.ts

@@ -0,0 +1,15 @@
+/**
+ * React Native service implementations for Uploadista client
+ */
+
+export { createReactNativeBase64Service } from "./base64-service";
+export {
+  createReactNativeServices,
+  type ReactNativeServiceOptions,
+} from "./create-react-native-services";
+
+export { createReactNativeFileReaderService } from "./file-reader-service";
+
+export { createReactNativeHttpClient } from "./http-client";
+export { createReactNativeIdGenerationService } from "./id-generation-service";
+export { createAsyncStorageService } from "./storage-service";

package/src/services/native-file-system-provider.ts

@@ -0,0 +1,247 @@
+import type {
+  CameraOptions,
+  FileInfo,
+  FilePickResult,
+  FileSystemProvider,
+  PickerOptions,
+} from "@uploadista/react-native-core";
+
+import * as DocumentPicker from "react-native-document-picker";
+import * as ImagePicker from "react-native-image-picker";
+import RNFetchBlob from "rn-fetch-blob";
+
+/**
+ * File system provider implementation for bare React Native environment
+ * Uses react-native-image-picker, react-native-fs, and native APIs
+ */
+export class NativeFileSystemProvider implements FileSystemProvider {
+  async pickDocument(options?: PickerOptions): Promise<FilePickResult> {
+    try {
+      const result = await DocumentPicker.pick({
+        type: options?.allowedTypes || [DocumentPicker.types.allFiles],
+        ...(options?.allowMultiple && { isMultiple: true }),
+      });
+
+      const file = Array.isArray(result) ? result[0] : result;
+
+      if (!file) {
+        throw new Error("No document selected");
+      }
+
+      return {
+        uri: file.uri,
+        name: file.name || "document",
+        size: file.size || 0,
+        mimeType: file.type || undefined,
+        localPath: file.fileCopyUri || undefined,
+      };
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        (error.message.includes("cancelled") ||
+          error.message.includes("Cancelled"))
+      ) {
+        throw error;
+      }
+      throw new Error(
+        `Failed to pick document: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  async pickImage(options?: PickerOptions): Promise<FilePickResult> {
+    try {
+      return new Promise((resolve, reject) => {
+        ImagePicker.launchImageLibrary(
+          {
+            mediaType: "photo",
+            selectionLimit: options?.allowMultiple ? 0 : 1,
+            quality: 1,
+            // biome-ignore lint/suspicious/noExplicitAny: react-native-image-picker type mismatch
+          } as any,
+          (response: unknown) => {
+            const res = response as {
+              didCancel?: boolean;
+              errorCode?: string;
+              assets?: Array<{
+                uri: string;
+                fileName?: string;
+                fileSize?: number;
+                type?: string;
+              }>;
+            };
+
+            if (res.didCancel) {
+              reject(new Error("Image picker was cancelled"));
+            } else if (res.errorCode) {
+              reject(new Error(`Image picker error: ${res.errorCode}`));
+            } else if (res.assets && res.assets.length > 0) {
+              const asset = res.assets[0];
+              if (asset) {
+                resolve({
+                  uri: asset.uri,
+                  name: asset.fileName || `image-${Date.now()}.jpg`,
+                  size: asset.fileSize || 0,
+                  mimeType: asset.type || "image/jpeg",
+                });
+              } else {
+                reject(new Error("No image selected"));
+              }
+            } else {
+              reject(new Error("No image selected"));
+            }
+          },
+        );
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to pick image: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  async pickVideo(options?: PickerOptions): Promise<FilePickResult> {
+    try {
+      return new Promise((resolve, reject) => {
+        ImagePicker.launchImageLibrary(
+          {
+            mediaType: "video",
+            selectionLimit: options?.allowMultiple ? 0 : 1,
+          },
+          (response: unknown) => {
+            const res = response as {
+              didCancel?: boolean;
+              errorCode?: string;
+              assets?: Array<{
+                uri: string;
+                fileName?: string;
+                fileSize?: number;
+                type?: string;
+              }>;
+            };
+
+            if (res.didCancel) {
+              reject(new Error("Video picker was cancelled"));
+            } else if (res.errorCode) {
+              reject(new Error(`Video picker error: ${res.errorCode}`));
+            } else if (res.assets && res.assets.length > 0) {
+              const asset = res.assets[0];
+              if (asset) {
+                resolve({
+                  uri: asset.uri,
+                  name: asset.fileName || `video-${Date.now()}.mp4`,
+                  size: asset.fileSize || 0,
+                  mimeType: asset.type || "video/mp4",
+                });
+              } else {
+                reject(new Error("No video selected"));
+              }
+            } else {
+              reject(new Error("No video selected"));
+            }
+          },
+        );
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to pick video: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  async pickCamera(options?: CameraOptions): Promise<FilePickResult> {
+    try {
+      return new Promise((resolve, reject) => {
+        ImagePicker.launchCamera(
+          {
+            mediaType: "photo",
+            cameraType: options?.cameraType === "front" ? "front" : "back",
+            quality: options?.quality ?? 1,
+            // biome-ignore lint/suspicious/noExplicitAny: react-native-image-picker type mismatch
+          } as any,
+          (response: unknown) => {
+            const res = response as {
+              didCancel?: boolean;
+              errorCode?: string;
+              assets?: Array<{
+                uri: string;
+                fileName?: string;
+                fileSize?: number;
+                type?: string;
+              }>;
+            };
+
+            if (res.didCancel) {
+              reject(new Error("Camera was cancelled"));
+            } else if (res.errorCode) {
+              reject(new Error(`Camera error: ${res.errorCode}`));
+            } else if (res.assets && res.assets.length > 0) {
+              const asset = res.assets[0];
+              if (asset) {
+                resolve({
+                  uri: asset.uri,
+                  name: asset.fileName || `photo-${Date.now()}.jpg`,
+                  size: asset.fileSize || 0,
+                  mimeType: asset.type || "image/jpeg",
+                });
+              } else {
+                reject(new Error("No photo captured"));
+              }
+            } else {
+              reject(new Error("No photo captured"));
+            }
+          },
+        );
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to capture photo: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  async readFile(uri: string): Promise<ArrayBuffer> {
+    try {
+      // Read file as base64
+      const base64Data = await RNFetchBlob.fs.readFile(uri, "base64");
+
+      // Convert base64 to ArrayBuffer
+      const binaryString = atob(base64Data);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      return bytes.buffer;
+    } catch (error) {
+      throw new Error(
+        `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  async getDocumentUri(filePath: string): Promise<string> {
+    // In bare RN with native modules, the path is typically already a URI
+    return filePath;
+  }
+
+  async getFileInfo(uri: string): Promise<FileInfo> {
+    try {
+      const stat = await RNFetchBlob.fs.stat(uri);
+
+      return {
+        uri,
+        name: stat.filename || uri.split("/").pop() || "unknown",
+        size: stat.size || 0,
+        modificationTime: stat.lastModified
+          ? typeof stat.lastModified === "string"
+            ? parseInt(stat.lastModified, 10)
+            : stat.lastModified
+          : undefined,
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get file info: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}