@uploadista/expo 0.0.3

package/src/services/fingerprint-service.ts

@@ -0,0 +1,107 @@
+import type { FingerprintService } from "@uploadista/client-core";
+import * as Crypto from "expo-crypto";
+import type { ExpoUploadInput } from "../types/upload-input";
+import { computeblobSha256 } from "../utils/hash-util";
+
+/**
+ * Creates a FingerprintService for Expo environments
+ * Computes file fingerprints using SHA-256 hashing
+ * Supports Blob, File, and URI-based inputs
+ */
+export function createExpoFingerprintService(): FingerprintService<ExpoUploadInput> {
+  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 Expo file URI
+ * Uses Expo FileSystem to read the file and compute its SHA-256 hash
+ */
+async function computeFingerprintFromUri(uri: string): Promise<string> {
+  try {
+    // Use Expo FileSystem to read the file as base64
+    const FileSystem = await getExpoFileSystem();
+    const fileInfo = await FileSystem.getInfoAsync(uri);
+
+    if (!fileInfo.exists) {
+      throw new Error(`File does not exist at URI: ${uri}`);
+    }
+
+    // Read the entire file as base64
+    const base64String = await FileSystem.readAsStringAsync(uri, {
+      encoding: FileSystem.EncodingType.Base64,
+    });
+
+    // Convert base64 to Uint8Array
+    const uint8Array = base64ToUint8Array(base64String);
+
+    // Compute SHA-256 hash directly on the Uint8Array
+    const hashBuffer = await Crypto.digest(
+      Crypto.CryptoDigestAlgorithm.SHA256,
+      uint8Array,
+    );
+
+    // Convert hash to hex string
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray
+      .map((byte) => byte.toString(16).padStart(2, "0"))
+      .join("");
+
+    return hashHex;
+  } catch (error) {
+    throw new Error(
+      `Failed to compute fingerprint from URI ${uri}: ${error instanceof Error ? error.message : "Unknown error"}`,
+    );
+  }
+}
+
+/**
+ * Dynamically import Expo FileSystem
+ * This allows the service to work even if expo-file-system is not installed
+ */
+async function getExpoFileSystem() {
+  try {
+    return require("expo-file-system");
+  } catch (_error) {
+    throw new Error(
+      "expo-file-system is required for URI-based fingerprinting. " +
+        "Please install it with: npx expo install expo-file-system",
+    );
+  }
+}
+
+/**
+ * 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)
+  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/http-client.ts

@@ -0,0 +1,235 @@
+import type {
+  ConnectionHealth,
+  ConnectionMetrics,
+  ConnectionPoolConfig,
+  DetailedConnectionMetrics,
+  HeadersLike,
+  Http2Info,
+  HttpClient,
+  HttpRequestOptions,
+  HttpResponse,
+} from "@uploadista/client-core";
+
+/**
+ * Expo-specific implementation of HttpClient using fetch API
+ * Expo's fetch is similar to browser fetch but optimized for React Native
+ */
+export function createExpoHttpClient(
+  config?: ConnectionPoolConfig,
+): HttpClient {
+  return new ExpoHttpClient(config);
+}
+
+/**
+ * Expo HTTP client implementation
+ */
+class ExpoHttpClient implements HttpClient {
+  private metrics: ConnectionMetrics;
+  private connectionTimes: number[] = [];
+  private requestCount = 0;
+  private errorCount = 0;
+  private timeoutCount = 0;
+  private retryCount = 0;
+  private startTime = Date.now();
+
+  constructor(_config: ConnectionPoolConfig = {}) {
+    // Configuration is stored for potential future use
+    // Currently Expo doesn't expose connection pool configuration
+
+    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,
+      // biome-ignore lint/suspicious/noExplicitAny: Expo's BodyInit type compatibility
+      body: options.body as any,
+      signal: options.signal as AbortSignal | undefined,
+    };
+
+    // Add credentials if specified
+    if (options.credentials) {
+      // biome-ignore lint/suspicious/noExplicitAny: Expo's RequestCredentials type compatibility
+      fetchOptions.credentials = options.credentials as any;
+    }
+
+    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.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, // Expo 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.errorCount = 0;
+    this.timeoutCount = 0;
+    this.retryCount = 0;
+    this.startTime = Date.now();
+  }
+
+  async close(): Promise<void> {
+    // Expo 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";
+
+/**
+ * Expo-specific implementation of IdGenerationService using uuid library
+ * crypto.randomUUID() is not available in Expo/React Native, so we use the uuid library
+ */
+export function createExpoIdGenerationService(): IdGenerationService {
+  return {
+    generate(): string {
+      return uuidv4();
+    },
+  };
+}

package/src/services/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Expo service implementations for Uploadista client
+ */
+
+export { createExpoBase64Service } from "./base64-service";
+export {
+  createExpoServices,
+  type ExpoServiceOptions,
+} from "./create-expo-services";
+export { createExpoFileReaderService } from "./file-reader-service";
+export { createExpoHttpClient } from "./http-client";
+export { createExpoIdGenerationService } from "./id-generation-service";
+export { createAsyncStorageService } from "./storage-service";

package/src/services/platform-service.ts

@@ -0,0 +1,71 @@
+import type { PlatformService, Timeout } from "@uploadista/client-core";
+
+/**
+ * Expo implementation of PlatformService
+ */
+export function createExpoPlatformService(): PlatformService {
+  return {
+    setTimeout: (callback: () => void, ms: number | undefined) => {
+      return globalThis.setTimeout(callback, ms);
+    },
+
+    clearTimeout: (id: Timeout) => {
+      globalThis.clearTimeout(id as number);
+    },
+
+    isBrowser: () => {
+      return false;
+    },
+
+    isOnline: () => {
+      // Expo's NetInfo would need to be imported separately
+      // For now, assume online
+      return true;
+    },
+
+    isFileLike: (value: unknown) => {
+      // Check for blob-like interface or File-like object
+      return (
+        value !== null &&
+        typeof value === "object" &&
+        ("uri" in value || "name" in value)
+      );
+    },
+
+    getFileName: (file: unknown) => {
+      if (file !== null && typeof file === "object" && "name" in file) {
+        return (file as Record<string, unknown>).name as string | undefined;
+      }
+      if (file !== null && typeof file === "object" && "uri" in file) {
+        const uri = (file as Record<string, unknown>).uri as string | undefined;
+        if (uri) {
+          return uri.split("/").pop();
+        }
+      }
+      return undefined;
+    },
+
+    getFileType: (file: unknown) => {
+      if (file !== null && typeof file === "object" && "type" in file) {
+        return (file as Record<string, unknown>).type as string | undefined;
+      }
+      return undefined;
+    },
+
+    getFileSize: (file: unknown) => {
+      if (file !== null && typeof file === "object" && "size" in file) {
+        return (file as Record<string, unknown>).size as number | undefined;
+      }
+      return undefined;
+    },
+
+    getFileLastModified: (file: unknown) => {
+      if (file !== null && typeof file === "object" && "lastModified" in file) {
+        return (file as Record<string, unknown>).lastModified as
+          | number
+          | undefined;
+      }
+      return undefined;
+    },
+  };
+}

package/src/services/storage-service.ts

@@ -0,0 +1,62 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import type { StorageService } from "@uploadista/client-core";
+/**
+ * Expo-specific implementation of StorageService using AsyncStorage
+ * AsyncStorage is provided as an optional peer dependency and must be installed separately
+ */
+export function createAsyncStorageService(): StorageService {
+  const findEntries = async (
+    prefix: string,
+  ): Promise<Record<string, string>> => {
+    const results: Record<string, string> = {};
+
+    const keys = await AsyncStorage.getAllKeys();
+    for (const key in keys) {
+      if (key.startsWith(prefix)) {
+        const item = await AsyncStorage.getItem(key);
+        if (item) {
+          results[key] = item;
+        }
+      }
+    }
+
+    return results;
+  };
+
+  return {
+    async getItem(key: string): Promise<string | null> {
+      try {
+        return await AsyncStorage.getItem(key);
+      } catch (error) {
+        console.error(`AsyncStorage getItem error for key ${key}:`, error);
+        return null;
+      }
+    },
+
+    async setItem(key: string, value: string): Promise<void> {
+      try {
+        await AsyncStorage.setItem(key, value);
+      } catch (error) {
+        console.error(`AsyncStorage setItem error for key ${key}:`, error);
+        throw error;
+      }
+    },
+
+    async removeItem(key: string): Promise<void> {
+      try {
+        await AsyncStorage.removeItem(key);
+      } catch (error) {
+        console.error(`AsyncStorage removeItem error for key ${key}:`, error);
+        throw error;
+      }
+    },
+
+    async findAll(): Promise<Record<string, string>> {
+      return findEntries("");
+    },
+
+    async find(prefix: string): Promise<Record<string, string>> {
+      return findEntries(prefix);
+    },
+  };
+}

package/src/services/websocket-factory.ts

@@ -0,0 +1,62 @@
+import type { WebSocketFactory, WebSocketLike } from "@uploadista/client-core";
+
+/**
+ * Expo WebSocket implementation that wraps native WebSocket
+ * Expo provides a WebSocket API that is compatible with the browser WebSocket API
+ */
+class ExpoWebSocket implements WebSocketLike {
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+
+  readyState: number;
+  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;
+
+  constructor(url: string) {
+    this.native = new WebSocket(url);
+    this.readyState = this.native.readyState;
+
+    // Proxy event handlers
+    this.native.onopen = () => {
+      this.readyState = this.native.readyState;
+      this.onopen?.();
+    };
+
+    this.native.onclose = (event) => {
+      this.readyState = this.native.readyState;
+      this.onclose?.({
+        code: event.code ?? 1000,
+        reason: event.reason ?? "undefined reason",
+      });
+    };
+
+    this.native.onerror = (event) => {
+      this.onerror?.(event);
+    };
+
+    this.native.onmessage = (event) => {
+      this.onmessage?.({ data: event.data });
+    };
+  }
+
+  send(data: string | Uint8Array): void {
+    this.native.send(data);
+  }
+
+  close(code?: number, reason?: string): void {
+    this.native.close(code, reason);
+  }
+}
+
+/**
+ * Factory for creating Expo WebSocket connections
+ */
+export const createExpoWebSocketFactory = (): WebSocketFactory => ({
+  create: (url: string): WebSocketLike => new ExpoWebSocket(url),
+});

package/src/types/upload-input.ts

@@ -0,0 +1,5 @@
+/**
+ * Expo file input types
+ * Can be a Blob, File, URI string, or URI object from Expo APIs
+ */
+export type ExpoUploadInput = Blob | File | string | { uri: string };

package/src/types.ts

@@ -0,0 +1,116 @@
+/**
+ * Core types for Expo Uploadista client
+ */
+
+/**
+ * Options for file picker operations
+ */
+export interface PickerOptions {
+  /** Allowed file types/MIME types */
+  allowedTypes?: string[];
+  /** Allow multiple selection */
+  allowMultiple?: boolean;
+  /** Maximum file size in bytes */
+  maxSize?: number;
+}
+
+/**
+ * Options for camera operations
+ */
+export interface CameraOptions {
+  /** Camera to use: 'front' or 'back' */
+  cameraType?: "front" | "back";
+  /** Image quality (0-1) */
+  quality?: number;
+  /** Maximum width for captured image */
+  maxWidth?: number;
+  /** Maximum height for captured image */
+  maxHeight?: number;
+}
+
+/**
+ * Result from a file pick operation
+ */
+export interface FilePickResult {
+  /** URI to the file (platform-specific format) */
+  uri: string;
+  /** File name with extension */
+  name: string;
+  /** File size in bytes */
+  size: number;
+  /** MIME type of the file (if available) */
+  mimeType?: string;
+  /** Local file path (if available) */
+  localPath?: string;
+}
+
+/**
+ * Information about a file
+ */
+export interface FileInfo {
+  /** URI to the file */
+  uri: string;
+  /** File name */
+  name: string;
+  /** File size in bytes */
+  size: number;
+  /** MIME type (if available) */
+  mimeType?: string;
+  /** Last modified timestamp */
+  modificationTime?: number;
+}
+
+/**
+ * Interface for file system abstraction layer
+ * Provides pluggable access to file system APIs across different Expo environments
+ */
+export interface FileSystemProvider {
+  /**
+   * Opens a document picker for selecting files
+   * @param options - Configuration for the picker
+   * @returns Promise resolving to picked file information
+   */
+  pickDocument(options?: PickerOptions): Promise<FilePickResult>;
+
+  /**
+   * Opens an image picker for selecting images from gallery
+   * @param options - Configuration for the picker
+   * @returns Promise resolving to picked image information
+   */
+  pickImage(options?: PickerOptions): Promise<FilePickResult>;
+
+  /**
+   * Opens a video picker for selecting videos from gallery
+   * @param options - Configuration for the picker
+   * @returns Promise resolving to picked video information
+   */
+  pickVideo(options?: PickerOptions): Promise<FilePickResult>;
+
+  /**
+   * Captures a photo using the device camera
+   * @param options - Configuration for camera
+   * @returns Promise resolving to captured photo information
+   */
+  pickCamera(options?: CameraOptions): Promise<FilePickResult>;
+
+  /**
+   * Gets a URI for a document that can be read
+   * @param filePath - Path to the document
+   * @returns Promise resolving to accessible URI
+   */
+  getDocumentUri(filePath: string): Promise<string>;
+
+  /**
+   * Reads file contents as ArrayBuffer
+   * @param uri - URI to read from
+   * @returns Promise resolving to file contents as ArrayBuffer
+   */
+  readFile(uri: string): Promise<ArrayBuffer>;
+
+  /**
+   * Gets information about a file
+   * @param uri - URI of the file
+   * @returns Promise resolving to file information
+   */
+  getFileInfo(uri: string): Promise<FileInfo>;
+}