@idealyst/files 1.2.96

package/src/permissions/permissions.native.ts

@@ -0,0 +1,177 @@
+import type { PermissionStatus, PermissionResult } from '../types';
+
+// Lazy load react-native-image-picker for permission checks
+let ImagePicker: typeof import('react-native-image-picker') | null = null;
+
+async function getImagePicker() {
+  if (!ImagePicker) {
+    ImagePicker = await import('react-native-image-picker');
+  }
+  return ImagePicker;
+}
+
+/**
+ * Map image picker permission to our PermissionStatus.
+ */
+function mapPermissionStatus(status: string): PermissionStatus {
+  switch (status) {
+    case 'granted':
+      return 'granted';
+    case 'denied':
+      return 'denied';
+    case 'blocked':
+      return 'blocked';
+    case 'unavailable':
+      return 'unavailable';
+    case 'limited':
+      return 'granted'; // Limited access is still usable
+    default:
+      return 'undetermined';
+  }
+}
+
+/**
+ * Check photo library permission on native.
+ */
+export async function checkPhotoLibraryPermission(): Promise<PermissionStatus> {
+  try {
+    const imagePicker = await getImagePicker();
+
+    // Check if the library exists and has the right method
+    if (typeof imagePicker.launchImageLibrary !== 'function') {
+      return 'unavailable';
+    }
+
+    // We can't directly check permissions without triggering the picker
+    // Return undetermined as we need to request to know
+    return 'undetermined';
+  } catch {
+    return 'unavailable';
+  }
+}
+
+/**
+ * Request photo library permission on native.
+ */
+export async function requestPhotoLibraryPermission(): Promise<PermissionStatus> {
+  try {
+    const imagePicker = await getImagePicker();
+
+    // Launch the image library to trigger permission request
+    // This is a common pattern since react-native-image-picker doesn't expose
+    // a direct permission request API
+    const result = await imagePicker.launchImageLibrary({
+      mediaType: 'mixed',
+      selectionLimit: 0,
+    });
+
+    if (result.didCancel) {
+      return 'granted'; // User cancelled but permission was granted
+    }
+
+    if (result.errorCode === 'permission') {
+      return 'denied';
+    }
+
+    return 'granted';
+  } catch (error) {
+    // If permission was denied, we'll get an error
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    if (errorMessage.toLowerCase().includes('permission')) {
+      return 'denied';
+    }
+
+    return 'unavailable';
+  }
+}
+
+/**
+ * Check camera permission on native.
+ */
+export async function checkCameraPermission(): Promise<PermissionStatus> {
+  try {
+    const imagePicker = await getImagePicker();
+
+    if (typeof imagePicker.launchCamera !== 'function') {
+      return 'unavailable';
+    }
+
+    return 'undetermined';
+  } catch {
+    return 'unavailable';
+  }
+}
+
+/**
+ * Request camera permission on native.
+ */
+export async function requestCameraPermission(): Promise<PermissionStatus> {
+  try {
+    const imagePicker = await getImagePicker();
+
+    // Launch camera to trigger permission request
+    const result = await imagePicker.launchCamera({
+      mediaType: 'photo',
+      saveToPhotos: false,
+    });
+
+    if (result.didCancel) {
+      return 'granted'; // User cancelled but permission was granted
+    }
+
+    if (result.errorCode === 'permission') {
+      return 'denied';
+    }
+
+    if (result.errorCode === 'camera_unavailable') {
+      return 'unavailable';
+    }
+
+    return 'granted';
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    if (errorMessage.toLowerCase().includes('permission')) {
+      return 'denied';
+    }
+
+    return 'unavailable';
+  }
+}
+
+/**
+ * Check all file-related permissions.
+ */
+export async function checkPermissions(): Promise<PermissionResult> {
+  const [photoLibrary, camera] = await Promise.all([
+    checkPhotoLibraryPermission(),
+    checkCameraPermission(),
+  ]);
+
+  return {
+    photoLibrary,
+    camera,
+    canAskAgain: photoLibrary === 'undetermined' || camera === 'undetermined',
+  };
+}
+
+/**
+ * Request all file-related permissions.
+ */
+export async function requestPermissions(): Promise<PermissionResult> {
+  // Request photo library first (more commonly needed)
+  const photoLibrary = await requestPhotoLibraryPermission();
+
+  // Only request camera if photo library was granted
+  let camera: PermissionStatus = 'undetermined';
+  if (photoLibrary === 'granted') {
+    camera = await requestCameraPermission();
+  }
+
+  return {
+    photoLibrary,
+    camera,
+    canAskAgain: photoLibrary === 'blocked' || camera === 'blocked' ? false : true,
+  };
+}

package/src/permissions/permissions.web.ts

@@ -0,0 +1,96 @@
+import type { PermissionStatus, PermissionResult } from '../types';
+
+/**
+ * Check photo library permission (always granted on web).
+ */
+export async function checkPhotoLibraryPermission(): Promise<PermissionStatus> {
+  // Web doesn't require permissions for file input
+  return 'granted';
+}
+
+/**
+ * Request photo library permission (no-op on web).
+ */
+export async function requestPhotoLibraryPermission(): Promise<PermissionStatus> {
+  // Web doesn't require permissions for file input
+  return 'granted';
+}
+
+/**
+ * Check camera permission for web.
+ */
+export async function checkCameraPermission(): Promise<PermissionStatus> {
+  if (!navigator.permissions) {
+    // Permissions API not supported, assume granted
+    return 'granted';
+  }
+
+  try {
+    const result = await navigator.permissions.query({ name: 'camera' as PermissionName });
+
+    switch (result.state) {
+      case 'granted':
+        return 'granted';
+      case 'denied':
+        return 'denied';
+      case 'prompt':
+      default:
+        return 'undetermined';
+    }
+  } catch {
+    // Camera permission query not supported in this browser
+    return 'undetermined';
+  }
+}
+
+/**
+ * Request camera permission for web.
+ */
+export async function requestCameraPermission(): Promise<PermissionStatus> {
+  try {
+    const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+    // Stop the stream immediately, we just needed to request permission
+    stream.getTracks().forEach(track => track.stop());
+    return 'granted';
+  } catch (error) {
+    if (error instanceof DOMException) {
+      if (error.name === 'NotAllowedError') {
+        return 'denied';
+      }
+      if (error.name === 'NotFoundError') {
+        return 'unavailable';
+      }
+    }
+    return 'denied';
+  }
+}
+
+/**
+ * Check all file-related permissions.
+ */
+export async function checkPermissions(): Promise<PermissionResult> {
+  const [photoLibrary, camera] = await Promise.all([
+    checkPhotoLibraryPermission(),
+    checkCameraPermission(),
+  ]);
+
+  return {
+    photoLibrary,
+    camera,
+    canAskAgain: camera === 'undetermined',
+  };
+}
+
+/**
+ * Request all file-related permissions.
+ */
+export async function requestPermissions(): Promise<PermissionResult> {
+  const photoLibrary = await requestPhotoLibraryPermission();
+  const camera = await requestCameraPermission();
+
+  return {
+    photoLibrary,
+    camera,
+    canAskAgain: false, // After requesting, user must change in settings
+  };
+}

package/src/picker/FilePicker.native.ts

@@ -0,0 +1,407 @@
+import type {
+  IFilePicker,
+  FilePickerConfig,
+  FilePickerResult,
+  FilePickerStatus,
+  FilePickerState,
+  PickedFile,
+  CameraOptions,
+  ValidationResult,
+  PermissionStatus,
+  FileType,
+} from '../types';
+import {
+  DEFAULT_FILE_PICKER_CONFIG,
+  INITIAL_FILE_PICKER_STATUS,
+  DOCUMENT_PICKER_TYPES,
+} from '../constants';
+import {
+  generateId,
+  validateFiles as validateFilesUtil,
+  createFilePickerError,
+  EventEmitter,
+  getFileExtension,
+} from '../utils';
+import { checkPermissions, requestPermissions } from '../permissions/permissions.native';
+
+// Lazy load native modules
+let DocumentPicker: typeof import('react-native-document-picker') | null = null;
+let ImagePicker: typeof import('react-native-image-picker') | null = null;
+
+async function getDocumentPicker() {
+  if (!DocumentPicker) {
+    DocumentPicker = await import('react-native-document-picker');
+  }
+  return DocumentPicker;
+}
+
+async function getImagePicker() {
+  if (!ImagePicker) {
+    ImagePicker = await import('react-native-image-picker');
+  }
+  return ImagePicker;
+}
+
+type FilePickerEvents = {
+  stateChange: [FilePickerStatus];
+};
+
+/**
+ * Native implementation of IFilePicker using react-native-document-picker and react-native-image-picker.
+ */
+export class NativeFilePicker implements IFilePicker {
+  private _status: FilePickerStatus = { ...INITIAL_FILE_PICKER_STATUS };
+  private _events = new EventEmitter<FilePickerEvents>();
+  private _defaultConfig: FilePickerConfig;
+  private _disposed = false;
+
+  constructor(config?: Partial<FilePickerConfig>) {
+    this._defaultConfig = { ...DEFAULT_FILE_PICKER_CONFIG, ...config };
+  }
+
+  get status(): FilePickerStatus {
+    return { ...this._status };
+  }
+
+  async checkPermission(): Promise<PermissionStatus> {
+    const result = await checkPermissions();
+    this._status.permission = result.photoLibrary;
+    return result.photoLibrary;
+  }
+
+  async requestPermission(): Promise<PermissionStatus> {
+    const result = await requestPermissions();
+    this._status.permission = result.photoLibrary;
+    return result.photoLibrary;
+  }
+
+  async pick(config?: Partial<FilePickerConfig>): Promise<FilePickerResult> {
+    if (this._disposed) {
+      return {
+        cancelled: true,
+        files: [],
+        rejected: [],
+        error: createFilePickerError('NOT_SUPPORTED', 'File picker has been disposed'),
+      };
+    }
+
+    const finalConfig = { ...this._defaultConfig, ...config };
+    this._updateState('picking');
+
+    try {
+      // Determine if we should use image picker or document picker
+      if (this._isMediaOnly(finalConfig.allowedTypes)) {
+        return await this._pickMedia(finalConfig);
+      } else {
+        return await this._pickDocuments(finalConfig);
+      }
+    } catch (error) {
+      this._updateState('error', createFilePickerError('UNKNOWN', 'Failed to pick files', error as Error));
+      return {
+        cancelled: false,
+        files: [],
+        rejected: [],
+        error: this._status.error,
+      };
+    }
+  }
+
+  async captureFromCamera(options?: CameraOptions): Promise<FilePickerResult> {
+    if (this._disposed) {
+      return {
+        cancelled: true,
+        files: [],
+        rejected: [],
+        error: createFilePickerError('NOT_SUPPORTED', 'File picker has been disposed'),
+      };
+    }
+
+    this._updateState('picking');
+
+    try {
+      const imagePicker = await getImagePicker();
+
+      const result = await imagePicker.launchCamera({
+        mediaType: this._mapMediaType(options?.mediaType || 'photo'),
+        quality: (options?.quality || 80) / 100,
+        durationLimit: options?.maxDuration,
+        saveToPhotos: options?.saveToLibrary ?? true,
+        cameraType: options?.useFrontCamera ? 'front' : 'back',
+        includeBase64: false,
+        includeExtra: true,
+      });
+
+      if (result.didCancel) {
+        this._updateState('idle');
+        return { cancelled: true, files: [], rejected: [] };
+      }
+
+      if (result.errorCode) {
+        this._updateState('idle');
+        return {
+          cancelled: false,
+          files: [],
+          rejected: [],
+          error: this._mapImagePickerError(result.errorCode, result.errorMessage),
+        };
+      }
+
+      this._updateState('processing');
+      const files = await this._transformImagePickerResponse(result);
+
+      this._updateState('idle');
+      return {
+        cancelled: false,
+        files,
+        rejected: [],
+      };
+    } catch (error) {
+      this._updateState('error', createFilePickerError('UNKNOWN', 'Failed to capture', error as Error));
+      return {
+        cancelled: false,
+        files: [],
+        rejected: [],
+        error: this._status.error,
+      };
+    }
+  }
+
+  validateFiles(files: File[] | PickedFile[], config?: Partial<FilePickerConfig>): ValidationResult {
+    const finalConfig = { ...this._defaultConfig, ...config };
+    return validateFilesUtil(files, finalConfig);
+  }
+
+  onStateChange(callback: (status: FilePickerStatus) => void): () => void {
+    return this._events.on('stateChange', callback);
+  }
+
+  dispose(): void {
+    this._disposed = true;
+    this._events.removeAllListeners();
+  }
+
+  // ============================================
+  // PRIVATE METHODS
+  // ============================================
+
+  private _updateState(state: FilePickerState, error?: ReturnType<typeof createFilePickerError>): void {
+    this._status = {
+      ...this._status,
+      state,
+      error,
+    };
+    this._events.emit('stateChange', this._status);
+  }
+
+  private _isMediaOnly(types: FileType[]): boolean {
+    const mediaTypes: FileType[] = ['image', 'video'];
+    return types.every(t => mediaTypes.includes(t));
+  }
+
+  private async _pickMedia(config: FilePickerConfig): Promise<FilePickerResult> {
+    const imagePicker = await getImagePicker();
+
+    const mediaType = this._getMediaTypeFromConfig(config);
+
+    const result = await imagePicker.launchImageLibrary({
+      mediaType,
+      selectionLimit: config.multiple ? (config.maxFiles || 0) : 1,
+      quality: (config.imageQuality || 80) / 100,
+      includeBase64: false,
+      includeExtra: true,
+    });
+
+    if (result.didCancel) {
+      this._updateState('idle');
+      return { cancelled: true, files: [], rejected: [] };
+    }
+
+    if (result.errorCode) {
+      this._updateState('idle');
+      return {
+        cancelled: false,
+        files: [],
+        rejected: [],
+        error: this._mapImagePickerError(result.errorCode, result.errorMessage),
+      };
+    }
+
+    this._updateState('processing');
+    const files = await this._transformImagePickerResponse(result, config);
+    const { accepted, rejected } = validateFilesUtil(files, config);
+
+    this._updateState('idle');
+    return {
+      cancelled: false,
+      files: accepted,
+      rejected,
+    };
+  }
+
+  private async _pickDocuments(config: FilePickerConfig): Promise<FilePickerResult> {
+    const docPicker = await getDocumentPicker();
+
+    const types = this._buildDocumentPickerTypes(config);
+
+    try {
+      const results = await docPicker.default.pick({
+        type: types,
+        allowMultiSelection: config.multiple,
+        copyTo: 'cachesDirectory',
+      });
+
+      this._updateState('processing');
+      const files = await this._transformDocumentPickerResponse(results, config);
+      const { accepted, rejected } = validateFilesUtil(files, config);
+
+      this._updateState('idle');
+      return {
+        cancelled: false,
+        files: accepted,
+        rejected,
+      };
+    } catch (error) {
+      const dp = await getDocumentPicker();
+      if (dp.default.isCancel(error)) {
+        this._updateState('idle');
+        return { cancelled: true, files: [], rejected: [] };
+      }
+
+      throw error;
+    }
+  }
+
+  private _getMediaTypeFromConfig(config: FilePickerConfig): 'photo' | 'video' | 'mixed' {
+    const hasImage = config.allowedTypes.includes('image');
+    const hasVideo = config.allowedTypes.includes('video');
+
+    if (hasImage && hasVideo) return 'mixed';
+    if (hasVideo) return 'video';
+    return 'photo';
+  }
+
+  private _mapMediaType(type: string): 'photo' | 'video' | 'mixed' {
+    switch (type) {
+      case 'video':
+        return 'video';
+      case 'mixed':
+        return 'mixed';
+      default:
+        return 'photo';
+    }
+  }
+
+  private _buildDocumentPickerTypes(config: FilePickerConfig): string[] {
+    const types = new Set<string>();
+
+    for (const fileType of config.allowedTypes) {
+      const docTypes = DOCUMENT_PICKER_TYPES[fileType] || [];
+      for (const t of docTypes) {
+        types.add(t);
+      }
+    }
+
+    return Array.from(types);
+  }
+
+  private async _transformImagePickerResponse(
+    response: import('react-native-image-picker').ImagePickerResponse,
+    config?: FilePickerConfig
+  ): Promise<PickedFile[]> {
+    const files: PickedFile[] = [];
+
+    for (const asset of response.assets || []) {
+      if (!asset.uri) continue;
+
+      const file: PickedFile = {
+        id: generateId(),
+        name: asset.fileName || `file_${Date.now()}`,
+        size: asset.fileSize || 0,
+        type: asset.type || 'application/octet-stream',
+        uri: asset.uri,
+        extension: getFileExtension(asset.fileName || ''),
+        lastModified: asset.timestamp ? new Date(asset.timestamp).getTime() : undefined,
+        dimensions: asset.width && asset.height ? { width: asset.width, height: asset.height } : undefined,
+        duration: asset.duration ? Math.round(asset.duration * 1000) : undefined,
+        getArrayBuffer: () => this._readFileAsArrayBuffer(asset.uri!),
+        getData: () => this._readFileAsBase64(asset.uri!),
+      };
+
+      files.push(file);
+    }
+
+    return files;
+  }
+
+  private async _transformDocumentPickerResponse(
+    results: import('react-native-document-picker').DocumentPickerResponse[],
+    config?: FilePickerConfig
+  ): Promise<PickedFile[]> {
+    const files: PickedFile[] = [];
+
+    for (const doc of results) {
+      const file: PickedFile = {
+        id: generateId(),
+        name: doc.name || `file_${Date.now()}`,
+        size: doc.size || 0,
+        type: doc.type || 'application/octet-stream',
+        uri: doc.fileCopyUri || doc.uri,
+        extension: getFileExtension(doc.name || ''),
+        getArrayBuffer: () => this._readFileAsArrayBuffer(doc.fileCopyUri || doc.uri),
+        getData: () => this._readFileAsBase64(doc.fileCopyUri || doc.uri),
+      };
+
+      files.push(file);
+    }
+
+    return files;
+  }
+
+  private _mapImagePickerError(errorCode: string, errorMessage?: string): ReturnType<typeof createFilePickerError> {
+    switch (errorCode) {
+      case 'permission':
+        return createFilePickerError('PERMISSION_DENIED', errorMessage || 'Permission denied');
+      case 'camera_unavailable':
+        return createFilePickerError('NOT_SUPPORTED', 'Camera is not available');
+      default:
+        return createFilePickerError('UNKNOWN', errorMessage || 'Unknown error');
+    }
+  }
+
+  private async _readFileAsArrayBuffer(uri: string): Promise<ArrayBuffer> {
+    // Use react-native-blob-util for file reading
+    try {
+      const BlobUtil = await import('react-native-blob-util');
+      const base64 = await BlobUtil.default.fs.readFile(uri.replace('file://', ''), 'base64');
+      return this._base64ToArrayBuffer(base64);
+    } catch {
+      // Fallback: return empty buffer if reading fails
+      return new ArrayBuffer(0);
+    }
+  }
+
+  private async _readFileAsBase64(uri: string): Promise<string> {
+    try {
+      const BlobUtil = await import('react-native-blob-util');
+      return await BlobUtil.default.fs.readFile(uri.replace('file://', ''), 'base64');
+    } catch {
+      return '';
+    }
+  }
+
+  private _base64ToArrayBuffer(base64: string): ArrayBuffer {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+}
+
+/**
+ * Create a new NativeFilePicker instance.
+ */
+export function createFilePicker(config?: Partial<FilePickerConfig>): IFilePicker {
+  return new NativeFilePicker(config);
+}