@uploadista/react-native-core 0.0.3

package/src/utils/permissions.ts

@@ -0,0 +1,177 @@
+/**
+ * Permission utility functions for React Native uploads
+ * Handles camera, gallery, and file access permissions
+ */
+
+/**
+ * Permission types
+ */
+export enum PermissionType {
+  CAMERA = "CAMERA",
+  PHOTO_LIBRARY = "PHOTO_LIBRARY",
+  WRITE_STORAGE = "WRITE_STORAGE",
+  READ_STORAGE = "READ_STORAGE",
+}
+
+/**
+ * Permission status
+ */
+export enum PermissionStatus {
+  GRANTED = "granted",
+  DENIED = "denied",
+  NOT_DETERMINED = "not_determined",
+  RESTRICTED = "restricted",
+}
+
+/**
+ * Request camera permission
+ * This is primarily used to check if we should attempt camera operations
+ * Actual permission requests are handled by the file system providers
+ *
+ * @returns Promise resolving to true if permission is granted or already granted
+ */
+export async function requestCameraPermission(): Promise<boolean> {
+  try {
+    // Permission requests are handled by the file system provider implementations
+    // This function serves as a placeholder for app-level permission handling
+    console.log(
+      "Camera permission requested (handled by file system provider)",
+    );
+    return true;
+  } catch (error) {
+    console.error("Failed to request camera permission:", error);
+    return false;
+  }
+}
+
+/**
+ * Request photo library permission
+ * @returns Promise resolving to true if permission is granted
+ */
+export async function requestPhotoLibraryPermission(): Promise<boolean> {
+  try {
+    console.log(
+      "Photo library permission requested (handled by file system provider)",
+    );
+    return true;
+  } catch (error) {
+    console.error("Failed to request photo library permission:", error);
+    return false;
+  }
+}
+
+/**
+ * Request storage read permission
+ * @returns Promise resolving to true if permission is granted
+ */
+export async function requestStorageReadPermission(): Promise<boolean> {
+  try {
+    console.log(
+      "Storage read permission requested (handled by file system provider)",
+    );
+    return true;
+  } catch (error) {
+    console.error("Failed to request storage read permission:", error);
+    return false;
+  }
+}
+
+/**
+ * Request storage write permission
+ * @returns Promise resolving to true if permission is granted
+ */
+export async function requestStorageWritePermission(): Promise<boolean> {
+  try {
+    console.log(
+      "Storage write permission requested (handled by file system provider)",
+    );
+    return true;
+  } catch (error) {
+    console.error("Failed to request storage write permission:", error);
+    return false;
+  }
+}
+
+/**
+ * Request multiple permissions at once
+ * @param permissions - Array of permission types to request
+ * @returns Promise resolving to true if all permissions are granted
+ */
+export async function requestPermissions(
+  permissions: PermissionType[],
+): Promise<boolean> {
+  try {
+    const results = await Promise.all(
+      permissions.map(async (permission) => {
+        switch (permission) {
+          case PermissionType.CAMERA:
+            return requestCameraPermission();
+          case PermissionType.PHOTO_LIBRARY:
+            return requestPhotoLibraryPermission();
+          case PermissionType.READ_STORAGE:
+            return requestStorageReadPermission();
+          case PermissionType.WRITE_STORAGE:
+            return requestStorageWritePermission();
+          default:
+            return false;
+        }
+      }),
+    );
+
+    return results.every((result) => result);
+  } catch (error) {
+    console.error("Failed to request permissions:", error);
+    return false;
+  }
+}
+
+/**
+ * Check if all required permissions are granted
+ * @param permissions - Array of permission types to check
+ * @returns Promise resolving to true if all permissions are granted
+ */
+export async function hasPermissions(
+  _permissions: PermissionType[],
+): Promise<boolean> {
+  try {
+    // In React Native, permission checking is typically handled by the platform
+    // This is a placeholder that assumes permissions will be handled by the file system provider
+    return true;
+  } catch (error) {
+    console.error("Failed to check permissions:", error);
+    return false;
+  }
+}
+
+/**
+ * Get permission status
+ * @param permission - Permission type to check
+ * @returns Promise resolving to permission status
+ */
+export async function getPermissionStatus(
+  _permission: PermissionType,
+): Promise<PermissionStatus> {
+  try {
+    // This is a placeholder implementation
+    // Real implementation would use platform-specific APIs
+    return PermissionStatus.GRANTED;
+  } catch (error) {
+    console.error("Failed to get permission status:", error);
+    return PermissionStatus.DENIED;
+  }
+}
+
+/**
+ * Open app settings to request permissions
+ * Guides user to app settings where they can manually enable permissions
+ */
+export function openAppSettings(): void {
+  try {
+    // This would typically use react-native-app-settings or similar
+    console.log(
+      "Opening app settings (requires react-native-app-settings or platform implementation)",
+    );
+  } catch (error) {
+    console.error("Failed to open app settings:", error);
+  }
+}

package/src/utils/uriHelpers.ts

@@ -0,0 +1,148 @@
+/**
+ * URI utility functions for React Native file handling
+ */
+
+/**
+ * Extract file name from URI
+ * @param uri - File URI
+ * @returns File name extracted from URI
+ */
+export function getFileNameFromUri(uri: string): string {
+  try {
+    // Handle different URI formats
+    if (uri.startsWith("file://")) {
+      // File URI format
+      const path = uri.replace("file://", "");
+      return path.split("/").pop() || "file";
+    }
+
+    if (uri.startsWith("content://")) {
+      // Content URI format (Android)
+      const parts = uri.split("/");
+      return parts[parts.length - 1] || "file";
+    }
+
+    // Assume it's a path or other format
+    const parts = uri.split("/");
+    return parts[parts.length - 1] || "file";
+  } catch {
+    return "file";
+  }
+}
+
+/**
+ * Convert file path to file URI
+ * @param filePath - File path
+ * @returns File URI
+ */
+export function pathToUri(filePath: string): string {
+  if (filePath.startsWith("file://")) {
+    return filePath;
+  }
+
+  if (filePath.startsWith("content://")) {
+    return filePath;
+  }
+
+  // Convert to file URI
+  return `file://${filePath}`;
+}
+
+/**
+ * Convert file URI to file path
+ * @param uri - File URI
+ * @returns File path
+ */
+export function uriToPath(uri: string): string {
+  if (uri.startsWith("file://")) {
+    return uri.replace("file://", "");
+  }
+
+  if (uri.startsWith("content://")) {
+    // Content URIs cannot be converted to paths directly
+    return uri;
+  }
+
+  return uri;
+}
+
+/**
+ * Get directory from URI
+ * @param uri - File URI
+ * @returns Directory path
+ */
+export function getDirectoryFromUri(uri: string): string {
+  try {
+    const path = uriToPath(uri);
+    const parts = path.split("/");
+    parts.pop(); // Remove file name
+    return parts.join("/");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Check if URI is a content URI (Android specific)
+ * @param uri - URI to check
+ * @returns True if URI is a content URI
+ */
+export function isContentUri(uri: string): boolean {
+  return uri.startsWith("content://");
+}
+
+/**
+ * Check if URI is a file URI
+ * @param uri - URI to check
+ * @returns True if URI is a file URI
+ */
+export function isFileUri(uri: string): boolean {
+  return uri.startsWith("file://");
+}
+
+/**
+ * Normalize URI for cross-platform compatibility
+ * @param uri - URI to normalize
+ * @returns Normalized URI
+ */
+export function normalizeUri(uri: string): string {
+  // Remove duplicate slashes (but keep protocol slashes)
+  return uri.replace(/([^:]\/)\/+/g, "$1");
+}
+
+/**
+ * Get MIME type hint from URI
+ * @param uri - File URI
+ * @returns MIME type hint based on file extension
+ */
+export function getMimeTypeFromUri(uri: string): string {
+  const fileName = getFileNameFromUri(uri);
+
+  const mimeTypes: Record<string, string> = {
+    // Images
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".bmp": "image/bmp",
+    ".webp": "image/webp",
+
+    // Videos
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".avi": "video/x-msvideo",
+
+    // Audio
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".aac": "audio/aac",
+
+    // Documents
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".json": "application/json",
+  };
+
+  const ext = fileName.toLowerCase().slice(fileName.lastIndexOf("."));
+  return mimeTypes[ext] || "application/octet-stream";
+}

package/test-compile.ts

@@ -0,0 +1,5 @@
+import type { IdGenerationService } from "@uploadista/client-core/services";
+
+const service: IdGenerationService = {
+  generate: () => "test",
+};

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "@uploadista/typescript-config/react-library.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "typeRoots": ["../../node_modules/@types"],
+    "types": [],
+    "target": "ES2020",
+    "lib": ["ES2020", "ES2015.Promise", "ES2015.Iterable", "ES2015.Symbol"],
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "skipLibCheck": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}