@uploadista/expo 0.0.3

package/src/index.ts

@@ -0,0 +1,77 @@
+/**
+ * Expo client for Uploadista
+ *
+ * This package provides Expo-specific implementations of the Uploadista client services,
+ * allowing file uploads through Expo's managed APIs.
+ *
+ * Usage:
+ * ```ts
+ * import { createUploadistaClient } from '@uploadista/expo'
+ *
+ * const client = createUploadistaClient({
+ *   baseUrl: 'https://api.example.com',
+ *   storageId: 'my-storage',
+ *   chunkSize: 1024 * 1024, // 1MB
+ * })
+ * ```
+ *
+ * Advanced usage with custom services:
+ * ```ts
+ * import { createExpoServices } from '@uploadista/expo/services'
+ * import { createUploadistaClientCore } from '@uploadista/client-core'
+ *
+ * const services = createExpoServices()
+ * const client = createUploadistaClientCore({
+ *   endpoint: 'https://api.example.com',
+ *   services
+ * })
+ * ```
+ *
+ * Legacy usage with FileSystemProvider (backward compatible):
+ * ```ts
+ * import { ExpoFileSystemProvider } from '@uploadista/expo'
+ *
+ * const provider = new ExpoFileSystemProvider()
+ * const file = await provider.pickImage()
+ * ```
+ */
+
+// Re-export core types from upload-client-core
+export type {
+  Base64Service,
+  ConnectionPoolConfig,
+  FileReaderService,
+  FileSource,
+  HttpClient,
+  HttpRequestOptions,
+  HttpResponse,
+  IdGenerationService,
+  ServiceContainer,
+  SliceResult,
+  StorageService,
+} from "@uploadista/client-core";
+// Export client factory
+export {
+  createUploadistaClient,
+  type UploadistaClientOptions,
+} from "./client";
+// Re-export service implementations and factories
+export {
+  createAsyncStorageService,
+  createExpoBase64Service,
+  createExpoFileReaderService,
+  createExpoHttpClient,
+  createExpoIdGenerationService,
+  createExpoServices,
+  type ExpoServiceOptions,
+} from "./services";
+
+export { ExpoFileSystemProvider } from "./services/expo-file-system-provider";
+// Export Expo-specific types
+export type {
+  CameraOptions,
+  FileInfo,
+  FilePickResult,
+  FileSystemProvider,
+  PickerOptions,
+} from "./types";

package/src/services/abort-controller-factory.ts

@@ -0,0 +1,32 @@
+import type {
+  AbortControllerFactory,
+  AbortControllerLike,
+  AbortSignalLike,
+} from "@uploadista/client-core";
+
+/**
+ * Expo AbortController implementation that wraps native AbortController
+ * Expo provides an AbortController API that is compatible with the browser AbortController API
+ */
+class ExpoAbortController implements AbortControllerLike {
+  private native: AbortController;
+
+  constructor() {
+    this.native = new AbortController();
+  }
+
+  get signal(): AbortSignalLike {
+    return this.native.signal;
+  }
+
+  abort(_reason?: unknown): void {
+    this.native.abort();
+  }
+}
+
+/**
+ * Factory for creating Expo AbortController instances
+ */
+export const createExpoAbortControllerFactory = (): AbortControllerFactory => ({
+  create: (): AbortControllerLike => new ExpoAbortController(),
+});

package/src/services/base64-service.ts

@@ -0,0 +1,29 @@
+import type { Base64Service } from "@uploadista/client-core";
+import { fromBase64 as decode, toBase64 as encode } from "js-base64";
+
+/**
+ * Expo-specific implementation of Base64Service using js-base64 library
+ * Expo/React Native doesn't have native btoa/atob functions, so we use js-base64
+ */
+export function createExpoBase64Service(): Base64Service {
+  return {
+    toBase64(data: ArrayBuffer): string {
+      // Convert ArrayBuffer to Uint8Array
+      const uint8Array = new Uint8Array(data);
+      // Convert Uint8Array to string
+      const binary = Array.from(uint8Array)
+        .map((byte) => String.fromCharCode(byte))
+        .join("");
+      return encode(binary);
+    },
+
+    fromBase64(data: string): ArrayBuffer {
+      const binary = decode(data);
+      const uint8Array = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) {
+        uint8Array[i] = binary.charCodeAt(i);
+      }
+      return uint8Array.buffer;
+    },
+  };
+}

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 createExpoChecksumService(): ChecksumService {
+  return {
+    computeChecksum: async (data: Uint8Array<ArrayBuffer>) => {
+      return computeUint8ArraySha256(data);
+    },
+  };
+}

package/src/services/create-expo-services.ts

@@ -0,0 +1,85 @@
+import {
+  type ConnectionPoolConfig,
+  createInMemoryStorageService,
+  type ServiceContainer,
+} from "@uploadista/client-core";
+import type { ReactNativeUploadInput } from "@uploadista/react-native-core";
+import { createExpoAbortControllerFactory } from "./abort-controller-factory";
+import { createExpoBase64Service } from "./base64-service";
+import { createExpoFileReaderService } from "./file-reader-service";
+import { createExpoHttpClient } from "./http-client";
+import { createExpoIdGenerationService } from "./id-generation-service";
+import { createExpoPlatformService } from "./platform-service";
+import { createAsyncStorageService } from "./storage-service";
+import { createExpoWebSocketFactory } from "./websocket-factory";
+import { createExpoChecksumService } from "./checksum-service";
+import { createExpoFingerprintService } from "./fingerprint-service";
+
+export interface ExpoServiceOptions {
+  /**
+   * HTTP client configuration for connection pooling
+   */
+  connectionPooling?: ConnectionPoolConfig;
+
+  /**
+   * Whether to use AsyncStorage for persistence
+   * If false, uses in-memory storage
+   * @default true
+   */
+  useAsyncStorage?: boolean;
+}
+
+/**
+ * Creates a service container with Expo-specific implementations
+ * of all required services for the upload client
+ *
+ * @param options - Configuration options for Expo services
+ * @returns ServiceContainer with Expo implementations
+ *
+ * @example
+ * ```typescript
+ * import { createExpoServices } from '@uploadista/expo/services';
+ *
+ * const services = createExpoServices({
+ *   useAsyncStorage: true,
+ *   connectionPooling: {
+ *     maxConnectionsPerHost: 6,
+ *     connectionTimeout: 30000,
+ *   }
+ * });
+ * ```
+ */
+export function createExpoServices(
+  options: ExpoServiceOptions = {},
+): ServiceContainer<ReactNativeUploadInput> {
+  const { connectionPooling, useAsyncStorage = true } = options;
+
+  // Create storage service (AsyncStorage or in-memory fallback)
+  const storage = useAsyncStorage
+    ? createAsyncStorageService()
+    : createInMemoryStorageService();
+
+  // Create other services
+  const idGeneration = createExpoIdGenerationService();
+  const httpClient = createExpoHttpClient(connectionPooling);
+  const fileReader = createExpoFileReaderService();
+  const base64 = createExpoBase64Service();
+  const websocket = createExpoWebSocketFactory();
+  const abortController = createExpoAbortControllerFactory();
+  const platform = createExpoPlatformService();
+  const checksumService = createExpoChecksumService();
+  const fingerprintService = createExpoFingerprintService();
+
+  return {
+    storage,
+    idGeneration,
+    httpClient,
+    fileReader,
+    base64,
+    websocket,
+    abortController,
+    platform,
+    checksumService,
+    fingerprintService,
+  };
+}

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

@@ -0,0 +1,227 @@
+import * as DocumentPicker from "expo-document-picker";
+import * as FileSystem from "expo-file-system";
+import * as ImagePicker from "expo-image-picker";
+import type {
+  CameraOptions,
+  FileInfo,
+  FilePickResult,
+  FileSystemProvider,
+  PickerOptions,
+} from "../types";
+
+/**
+ * File system provider implementation for Expo managed environment
+ * Uses Expo DocumentPicker, ImagePicker, Camera, and FileSystem APIs
+ */
+export class ExpoFileSystemProvider implements FileSystemProvider {
+  async pickDocument(options?: PickerOptions): Promise<FilePickResult> {
+    try {
+      const result = (await DocumentPicker.getDocumentAsync({
+        type: options?.allowedTypes || ["*/*"],
+        copyToCacheDirectory: true,
+      })) as {
+        canceled: boolean;
+        assets?: Array<{
+          uri: string;
+          name: string;
+          size?: number;
+          mimeType?: string;
+        }>;
+      };
+
+      if (result.canceled) {
+        throw new Error("Document picker was cancelled");
+      }
+
+      const asset = result.assets?.[0];
+      if (!asset) {
+        throw new Error("No document selected");
+      }
+
+      return {
+        uri: asset.uri,
+        name: asset.name,
+        size: asset.size || 0,
+        mimeType: asset.mimeType,
+      };
+    } catch (error) {
+      if (error instanceof Error && 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 {
+      // Request permissions
+      const { status } =
+        await ImagePicker.requestMediaLibraryPermissionsAsync();
+      if (status !== "granted") {
+        throw new Error("Camera roll permission not granted");
+      }
+
+      const result = await ImagePicker.launchImageLibraryAsync({
+        // biome-ignore lint/suspicious/noExplicitAny: Expo ImagePicker mediaTypes type compatibility
+        mediaTypes: "Images" as any,
+        selectionLimit: options?.allowMultiple ? 0 : 1,
+        quality: 1,
+      });
+
+      if (result.canceled) {
+        throw new Error("Image picker was cancelled");
+      }
+
+      const asset = result.assets?.[0];
+      if (!asset) {
+        throw new Error("No image selected");
+      }
+
+      return {
+        uri: asset.uri,
+        name: asset.fileName || `image-${Date.now()}.jpg`,
+        size: asset.fileSize || 0,
+        mimeType: "image/jpeg",
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("cancelled")) {
+        throw error;
+      }
+      throw new Error(
+        `Failed to pick image: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  async pickVideo(options?: PickerOptions): Promise<FilePickResult> {
+    try {
+      // Request permissions
+      const { status } =
+        await ImagePicker.requestMediaLibraryPermissionsAsync();
+      if (status !== "granted") {
+        throw new Error("Camera roll permission not granted");
+      }
+
+      const result = await ImagePicker.launchImageLibraryAsync({
+        // biome-ignore lint/suspicious/noExplicitAny: Expo ImagePicker mediaTypes type compatibility
+        mediaTypes: "Videos" as any,
+        selectionLimit: options?.allowMultiple ? 0 : 1,
+      });
+
+      if (result.canceled) {
+        throw new Error("Video picker was cancelled");
+      }
+
+      const asset = result.assets?.[0];
+      if (!asset) {
+        throw new Error("No video selected");
+      }
+
+      return {
+        uri: asset.uri,
+        name: asset.fileName || `video-${Date.now()}.mp4`,
+        size: asset.fileSize || 0,
+        mimeType: "video/mp4",
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("cancelled")) {
+        throw error;
+      }
+      throw new Error(
+        `Failed to pick video: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  async pickCamera(options?: CameraOptions): Promise<FilePickResult> {
+    try {
+      // Request camera permissions
+      const { status } = await ImagePicker.requestCameraPermissionsAsync();
+      if (status !== "granted") {
+        throw new Error("Camera permission not granted");
+      }
+
+      const result = await ImagePicker.launchCameraAsync({
+        allowsEditing: false,
+        aspect: [4, 3],
+        quality: options?.quality ?? 1,
+      });
+
+      if (result.canceled) {
+        throw new Error("Camera capture was cancelled");
+      }
+
+      const asset = result.assets?.[0];
+      if (!asset) {
+        throw new Error("No photo captured");
+      }
+
+      return {
+        uri: asset.uri,
+        name: asset.fileName || `photo-${Date.now()}.jpg`,
+        size: asset.fileSize || 0,
+        mimeType: "image/jpeg",
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("cancelled")) {
+        throw 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 base64String = await FileSystem.readAsStringAsync(uri, {
+        encoding: FileSystem.EncodingType.Base64,
+      });
+
+      // Convert base64 to ArrayBuffer
+      // Use js-base64 for decoding since atob is not available in all RN environments
+      const { fromBase64 } = await import("js-base64");
+      const binaryString = fromBase64(base64String);
+      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 Expo, the file path is typically already a URI
+    return filePath;
+  }
+
+  async getFileInfo(uri: string): Promise<FileInfo> {
+    try {
+      const fileInfo = await FileSystem.getInfoAsync(uri);
+
+      if (!fileInfo.exists) {
+        throw new Error("File does not exist");
+      }
+
+      return {
+        uri,
+        name: uri.split("/").pop() || "unknown",
+        size: fileInfo.size ?? 0,
+        modificationTime: fileInfo.modificationTime
+          ? fileInfo.modificationTime * 1000
+          : undefined,
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get file info: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

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

@@ -0,0 +1,184 @@
+import type {
+  FileReaderService,
+  FileSource,
+  SliceResult,
+} from "@uploadista/client-core";
+import type { ExpoUploadInput } from "@/types/upload-input";
+
+/**
+ * Expo-specific implementation of FileReaderService
+ * Handles Blob, File, and URI-based file inputs using Expo FileSystem APIs
+ */
+export function createExpoFileReaderService(): FileReaderService<ExpoUploadInput> {
+  return {
+    async openFile(input: unknown, _chunkSize: number): Promise<FileSource> {
+      // Handle Blob/File objects
+      if (input instanceof Blob) {
+        return createBlobFileSource(input);
+      }
+
+      // Handle URI strings or URI objects from Expo APIs
+      if (
+        typeof input === "string" ||
+        (input && typeof input === "object" && "uri" in input)
+      ) {
+        const uri =
+          typeof input === "string" ? input : (input as { uri: string }).uri;
+        return createExpoUriFileSource(uri);
+      }
+
+      throw new Error(
+        "Unsupported file input type for Expo. 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/Expo Blob may not have arrayBuffer() method
+      // Always use FileReader fallback for compatibility
+      const 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,
+    lastModified: null,
+    type: null,
+  };
+}
+
+/**
+ * Convert Blob to ArrayBuffer using FileReader (fallback for React Native/Expo)
+ */
+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 using Expo FileSystem
+ * This implementation uses expo-file-system for native file access
+ */
+function createExpoUriFileSource(uri: string): FileSource {
+  // For Expo URIs, we use FileSystem to read the file
+  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 {
+          // 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}`);
+          }
+
+          cachedSize = fileInfo.size ?? 0;
+
+          // Read the entire file as base64
+          const base64String = await FileSystem.readAsStringAsync(uri, {
+            encoding: FileSystem.EncodingType.Base64,
+          });
+
+          // Convert base64 to Uint8Array and cache size
+          const uint8Array = base64ToUint8Array(base64String);
+          cachedSize = uint8Array.length;
+
+          // Create a Blob from the Uint8Array buffer
+          // React Native Blob constructor accepts array-like objects
+          // biome-ignore lint/suspicious/noExplicitAny: React Native Blob constructor type compatibility
+          cachedBlob = new Blob([uint8Array.buffer] as any);
+        } catch (error) {
+          throw new Error(`Failed to read file from URI ${uri}: ${error}`);
+        }
+      }
+
+      const chunk = cachedBlob.slice(start, end);
+
+      // React Native/Expo Blob may not have arrayBuffer() method
+      // Always use FileReader fallback for compatibility
+      const 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;
+    },
+    name: uri,
+    lastModified: null,
+    type: null,
+  };
+}
+
+/**
+ * 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 but not installed. " +
+        "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;
+}