@oxyhq/services 6.9.13 → 6.9.15

package/src/ui/utils/fileManagement.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFileSize = formatFileSize;
+exports.getFileIcon = getFileIcon;
+exports.confirmAction = confirmAction;
+exports.convertDocumentPickerAssetToFile = convertDocumentPickerAssetToFile;
+exports.getSafeDownloadUrl = getSafeDownloadUrl;
+exports.uploadFileRaw = uploadFileRaw;
+exports.createAvatarPickerHandler = createAvatarPickerHandler;
+const react_native_1 = require("react-native");
+const sonner_1 = require("../../lib/sonner");
+const core_1 = require("@oxyhq/core");
+/**
+ * Format file size in bytes to human-readable string
+ */
+function formatFileSize(bytes) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+/**
+ * Get icon name for file based on content type
+ */
+function getFileIcon(contentType) {
+    if (contentType.startsWith('image/'))
+        return 'image';
+    if (contentType.startsWith('video/'))
+        return 'videocam';
+    if (contentType.startsWith('audio/'))
+        return 'musical-notes';
+    if (contentType.includes('pdf'))
+        return 'document-text';
+    if (contentType.includes('word') || contentType.includes('doc'))
+        return 'document';
+    if (contentType.includes('excel') || contentType.includes('sheet'))
+        return 'grid';
+    if (contentType.includes('zip') || contentType.includes('archive'))
+        return 'archive';
+    return 'document-outline';
+}
+/**
+ * Unified confirmation dialog - uses Alert.alert for all platforms
+ */
+function confirmAction(message, title, confirmText = 'OK', cancelText = 'Cancel') {
+    return new Promise((resolve) => {
+        react_native_1.Alert.alert(title || 'Confirm', message, [
+            {
+                text: cancelText,
+                style: 'cancel',
+                onPress: () => resolve(false),
+            },
+            {
+                text: confirmText,
+                onPress: () => resolve(true),
+            },
+        ], { cancelable: true, onDismiss: () => resolve(false) });
+    });
+}
+/**
+ * Convert DocumentPicker asset to File object
+ * Handles both web (native File API) and mobile (URI-based) file sources
+ * Expo 54 compatible - works across all platforms
+ */
+async function convertDocumentPickerAssetToFile(doc, index) {
+    try {
+        let file = null;
+        // Priority 1: Use doc.file if available (web native File API)
+        // This is the most efficient path as it doesn't require fetching
+        if (doc.file && doc.file instanceof globalThis.File) {
+            file = doc.file;
+            // Ensure file has required properties
+            if (!file.name && doc.name) {
+                // Create new File with proper name if missing
+                file = new globalThis.File([file], doc.name, { type: file.type || doc.mimeType || 'application/octet-stream' });
+            }
+            // Preserve URI for preview if available (useful for mobile previews)
+            if (doc.uri) {
+                file.uri = doc.uri;
+            }
+            return file;
+        }
+        // Priority 2: Use uri to create File using Expo 54 FileSystem API
+        // This path handles mobile file URIs (file://, content://) and web blob URLs
+        if (doc.uri) {
+            try {
+                // Check if it's a web blob URL - use fetch for those
+                if (doc.uri.startsWith('blob:') || doc.uri.startsWith('http://') || doc.uri.startsWith('https://')) {
+                    const response = await fetch(doc.uri);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch file: ${response.statusText}`);
+                    }
+                    const blob = await response.blob();
+                    const fileName = doc.name || `file-${index + 1}`;
+                    const fileType = doc.mimeType || blob.type || 'application/octet-stream';
+                    file = new globalThis.File([blob], fileName, { type: fileType });
+                    // Preserve URI for preview
+                    file.uri = doc.uri;
+                    return file;
+                }
+                // For mobile file URIs (file://, content://), use fetch to get blob
+                // React Native's Blob doesn't support Uint8Array directly, so we use fetch
+                const fileName = doc.name || `file-${index + 1}`;
+                const fileType = doc.mimeType || 'application/octet-stream';
+                // Use fetch to get the file as a blob (works with file:// and content:// URIs in React Native)
+                const response = await fetch(doc.uri);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch file: ${response.statusText}`);
+                }
+                const blob = await response.blob();
+                file = new globalThis.File([blob], fileName, { type: fileType });
+                // Preserve URI for preview (especially important for mobile)
+                file.uri = doc.uri;
+                return file;
+            }
+            catch (error) {
+                console.error('Failed to read file from URI:', error);
+                throw new Error(`Failed to load file: ${(error instanceof Error ? error.message : null) || 'Unknown error'}`);
+            }
+        }
+        // No file or URI available - this shouldn't happen with Expo 54
+        throw new Error('Missing file data (no file or uri property)');
+    }
+    catch (error) {
+        console.error('Error converting document to file:', error);
+        throw error;
+    }
+}
+/**
+ * Helper to safely request a thumbnail variant only for image mime types.
+ * Prevents backend warnings: "Variant thumb not supported for mime application/pdf".
+ *
+ * @param file - File metadata
+ * @param variant - Variant type (default: 'thumb')
+ * @param getFileDownloadUrl - Function to get download URL from oxyServices
+ */
+function getSafeDownloadUrl(file, variant, getFileDownloadUrl) {
+    const isImage = file.contentType.startsWith('image/');
+    const isVideo = file.contentType.startsWith('video/');
+    // Prefer explicit variant key if variants metadata present
+    if (file.variants && file.variants.length > 0) {
+        // For videos, try 'poster' regardless of requested variant
+        if (isVideo) {
+            const poster = file.variants.find(v => v.type === 'poster');
+            if (poster)
+                return getFileDownloadUrl(file.id, 'poster');
+        }
+        if (isImage) {
+            const desired = file.variants.find(v => v.type === variant);
+            if (desired)
+                return getFileDownloadUrl(file.id, variant);
+        }
+    }
+    if (isImage) {
+        return getFileDownloadUrl(file.id, variant);
+    }
+    if (isVideo) {
+        // Fallback to poster if backend supports implicit generation
+        try {
+            return getFileDownloadUrl(file.id, 'poster');
+        }
+        catch {
+            return getFileDownloadUrl(file.id);
+        }
+    }
+    // Other mime types: no variant
+    return getFileDownloadUrl(file.id);
+}
+/**
+ * Upload file raw - helper function for file uploads
+ */
+async function uploadFileRaw(file, userId, 
+// biome-ignore lint/suspicious/noExplicitAny: OxyServices type cannot be fully resolved due to mixin composition pattern
+oxyServices, visibility) {
+    return await oxyServices.uploadRawFile(file, visibility);
+}
+/**
+ * Creates a reusable avatar picker handler function.
+ *
+ * This function navigates to the FileManagement screen and handles:
+ * - Image file validation
+ * - File visibility update to public
+ * - Profile avatar update via mutation
+ * - Success/error toast notifications
+ *
+ * @example
+ * ```tsx
+ * const openAvatarPicker = createAvatarPickerHandler({
+ *   navigate,
+ *   oxyServices,
+ *   updateProfileMutation,
+ *   onAvatarSelected: setAvatarFileId,
+ *   t,
+ *   contextName: 'AccountSettings'
+ * });
+ *
+ * <TouchableOpacity onPress={openAvatarPicker}>
+ *   <Text>Change Avatar</Text>
+ * </TouchableOpacity>
+ * ```
+ */
+function createAvatarPickerHandler(config) {
+    const { navigate, oxyServices, updateProfileMutation, onAvatarSelected, t, contextName = 'AvatarPicker' } = config;
+    return () => {
+        if (!navigate) {
+            console.warn(`[${contextName}] navigate function is not available`);
+            return;
+        }
+        navigate('FileManagement', {
+            selectMode: true,
+            multiSelect: false,
+            disabledMimeTypes: ['video/', 'audio/', 'application/pdf'],
+            afterSelect: 'none', // Don't navigate away - stay on current screen
+            onSelect: async (file) => {
+                if (!file.contentType.startsWith('image/')) {
+                    sonner_1.toast.error(t('editProfile.toasts.selectImage') || 'Please select an image file');
+                    return;
+                }
+                try {
+                    // Update file visibility to public for avatar
+                    await (0, core_1.updateAvatarVisibility)(file.id, oxyServices, contextName);
+                    // Update local state if callback provided
+                    if (onAvatarSelected) {
+                        onAvatarSelected(file.id);
+                    }
+                    // Update user using TanStack Query mutation
+                    await updateProfileMutation.mutateAsync({ avatar: file.id });
+                    sonner_1.toast.success(t('editProfile.toasts.avatarUpdated') || 'Avatar updated');
+                }
+                catch (e) {
+                    sonner_1.toast.error((e instanceof Error ? e.message : null) || t('editProfile.toasts.updateAvatarFailed') || 'Failed to update avatar');
+                }
+            }
+        });
+    };
+}

package/src/ui/utils/iconNames.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Type-safe icon name utilities
+ *
+ * Provides centralized, typed icon name mappings to eliminate `as any` casts
+ * when using dynamic icon names with @expo/vector-icons.
+ */
+/**
+ * Profile field icons (MaterialCommunityIcons)
+ */
+export declare const PROFILE_FIELD_ICONS: {
+    readonly displayName: "account-outline";
+    readonly username: "at";
+    readonly email: "email-outline";
+    readonly bio: "text-box-outline";
+    readonly location: "map-marker-outline";
+    readonly links: "link-variant";
+    readonly website: "web";
+    readonly phone: "phone-outline";
+    readonly birthday: "cake-variant-outline";
+};
+export type ProfileFieldIconKey = keyof typeof PROFILE_FIELD_ICONS;
+/**
+ * Get icon name for a profile field
+ */
+export declare function getProfileFieldIcon(field: string): string;
+/**
+ * Settings section icons (MaterialCommunityIcons)
+ */
+export declare const SETTINGS_ICONS: {
+    readonly account: "account-cog-outline";
+    readonly privacy: "shield-account-outline";
+    readonly security: "lock-outline";
+    readonly notifications: "bell-outline";
+    readonly language: "translate";
+    readonly appearance: "palette-outline";
+    readonly storage: "folder-outline";
+    readonly help: "help-circle-outline";
+    readonly about: "information-outline";
+    readonly logout: "logout";
+};
+export type SettingsIconKey = keyof typeof SETTINGS_ICONS;
+/**
+ * Get icon name for a settings section
+ */
+export declare function getSettingsIcon(section: string): string;
+/**
+ * File type icons (MaterialCommunityIcons)
+ */
+export declare const FILE_TYPE_ICONS: {
+    readonly image: "image-outline";
+    readonly video: "video-outline";
+    readonly audio: "music-note-outline";
+    readonly document: "file-document-outline";
+    readonly pdf: "file-pdf-box";
+    readonly archive: "folder-zip-outline";
+    readonly code: "code-tags";
+    readonly spreadsheet: "file-excel-outline";
+    readonly presentation: "file-presentation-outline";
+    readonly text: "file-document-edit-outline";
+    readonly unknown: "file-outline";
+};
+export type FileTypeIconKey = keyof typeof FILE_TYPE_ICONS;
+/**
+ * Get icon name for a file type
+ */
+export declare function getFileTypeIcon(type: string): string;
+/**
+ * Action icons (Ionicons)
+ */
+export declare const ACTION_ICONS: {
+    readonly close: "close";
+    readonly back: "chevron-back";
+    readonly forward: "chevron-forward";
+    readonly add: "add";
+    readonly remove: "remove";
+    readonly delete: "trash-outline";
+    readonly edit: "pencil-outline";
+    readonly save: "checkmark";
+    readonly cancel: "close";
+    readonly search: "search-outline";
+    readonly filter: "filter-outline";
+    readonly sort: "swap-vertical-outline";
+    readonly refresh: "refresh-outline";
+    readonly share: "share-outline";
+    readonly copy: "copy-outline";
+    readonly download: "download-outline";
+    readonly upload: "cloud-upload-outline";
+};
+export type ActionIconKey = keyof typeof ACTION_ICONS;
+/**
+ * Get icon name for an action
+ */
+export declare function getActionIcon(action: string): string;
+/**
+ * Status icons (Ionicons)
+ */
+export declare const STATUS_ICONS: {
+    readonly success: "checkmark-circle";
+    readonly error: "alert-circle";
+    readonly warning: "warning";
+    readonly info: "information-circle";
+    readonly loading: "hourglass-outline";
+    readonly pending: "time-outline";
+    readonly online: "ellipse";
+    readonly offline: "ellipse-outline";
+};
+export type StatusIconKey = keyof typeof STATUS_ICONS;
+/**
+ * Get icon name for a status
+ */
+export declare function getStatusIcon(status: string): string;

package/src/ui/utils/iconNames.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Type-safe icon name utilities
+ *
+ * Provides centralized, typed icon name mappings to eliminate `as any` casts
+ * when using dynamic icon names with @expo/vector-icons.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATUS_ICONS = exports.ACTION_ICONS = exports.FILE_TYPE_ICONS = exports.SETTINGS_ICONS = exports.PROFILE_FIELD_ICONS = void 0;
+exports.getProfileFieldIcon = getProfileFieldIcon;
+exports.getSettingsIcon = getSettingsIcon;
+exports.getFileTypeIcon = getFileTypeIcon;
+exports.getActionIcon = getActionIcon;
+exports.getStatusIcon = getStatusIcon;
+/**
+ * Profile field icons (MaterialCommunityIcons)
+ */
+exports.PROFILE_FIELD_ICONS = {
+    displayName: 'account-outline',
+    username: 'at',
+    email: 'email-outline',
+    bio: 'text-box-outline',
+    location: 'map-marker-outline',
+    links: 'link-variant',
+    website: 'web',
+    phone: 'phone-outline',
+    birthday: 'cake-variant-outline',
+};
+/**
+ * Get icon name for a profile field
+ */
+function getProfileFieldIcon(field) {
+    return exports.PROFILE_FIELD_ICONS[field] ?? 'account-outline';
+}
+/**
+ * Settings section icons (MaterialCommunityIcons)
+ */
+exports.SETTINGS_ICONS = {
+    account: 'account-cog-outline',
+    privacy: 'shield-account-outline',
+    security: 'lock-outline',
+    notifications: 'bell-outline',
+    language: 'translate',
+    appearance: 'palette-outline',
+    storage: 'folder-outline',
+    help: 'help-circle-outline',
+    about: 'information-outline',
+    logout: 'logout',
+};
+/**
+ * Get icon name for a settings section
+ */
+function getSettingsIcon(section) {
+    return exports.SETTINGS_ICONS[section] ?? 'cog-outline';
+}
+/**
+ * File type icons (MaterialCommunityIcons)
+ */
+exports.FILE_TYPE_ICONS = {
+    image: 'image-outline',
+    video: 'video-outline',
+    audio: 'music-note-outline',
+    document: 'file-document-outline',
+    pdf: 'file-pdf-box',
+    archive: 'folder-zip-outline',
+    code: 'code-tags',
+    spreadsheet: 'file-excel-outline',
+    presentation: 'file-presentation-outline',
+    text: 'file-document-edit-outline',
+    unknown: 'file-outline',
+};
+/**
+ * Get icon name for a file type
+ */
+function getFileTypeIcon(type) {
+    return exports.FILE_TYPE_ICONS[type] ?? exports.FILE_TYPE_ICONS.unknown;
+}
+/**
+ * Action icons (Ionicons)
+ */
+exports.ACTION_ICONS = {
+    close: 'close',
+    back: 'chevron-back',
+    forward: 'chevron-forward',
+    add: 'add',
+    remove: 'remove',
+    delete: 'trash-outline',
+    edit: 'pencil-outline',
+    save: 'checkmark',
+    cancel: 'close',
+    search: 'search-outline',
+    filter: 'filter-outline',
+    sort: 'swap-vertical-outline',
+    refresh: 'refresh-outline',
+    share: 'share-outline',
+    copy: 'copy-outline',
+    download: 'download-outline',
+    upload: 'cloud-upload-outline',
+};
+/**
+ * Get icon name for an action
+ */
+function getActionIcon(action) {
+    return exports.ACTION_ICONS[action] ?? 'ellipsis-horizontal';
+}
+/**
+ * Status icons (Ionicons)
+ */
+exports.STATUS_ICONS = {
+    success: 'checkmark-circle',
+    error: 'alert-circle',
+    warning: 'warning',
+    info: 'information-circle',
+    loading: 'hourglass-outline',
+    pending: 'time-outline',
+    online: 'ellipse',
+    offline: 'ellipse-outline',
+};
+/**
+ * Get icon name for a status
+ */
+function getStatusIcon(status) {
+    return exports.STATUS_ICONS[status] ?? 'help-circle-outline';
+}

package/src/ui/utils/sessionHelpers.d.ts

@@ -0,0 +1,64 @@
+import type { ClientSession } from '@oxyhq/core';
+interface DeviceSession {
+    sessionId: string;
+    deviceId?: string;
+    deviceName?: string;
+    expiresAt?: string;
+    lastActive?: string;
+    user?: {
+        id?: string;
+        _id?: {
+            toString(): string;
+        };
+    };
+    userId?: string;
+    isCurrent?: boolean;
+}
+/**
+ * Service type for session helpers.
+ * Uses 'unknown' to work around TypeScript mixin composition type inference issues.
+ * The OxyServices class has these methods but TypeScript can't see them due to the mixin pattern.
+ * Methods are accessed dynamically, so callers must pass a properly typed instance.
+ */
+type OxyServicesAny = any;
+export interface FetchSessionsWithFallbackOptions {
+    fallbackDeviceId?: string;
+    fallbackUserId?: string;
+    logger?: (message: string, error?: unknown) => void;
+}
+export interface ValidateSessionBatchOptions {
+    useHeaderValidation?: boolean;
+    maxConcurrency?: number;
+}
+export interface SessionValidationResult {
+    sessionId: string;
+    valid: boolean;
+    user?: unknown;
+    raw?: unknown;
+    error?: unknown;
+}
+/**
+ * Normalize backend session payloads into `ClientSession` objects.
+ *
+ * @param sessions - Raw session array returned from the API
+ * @param fallbackDeviceId - Device identifier to use when missing from payload
+ * @param fallbackUserId - User identifier to use when missing from payload
+ */
+export declare const mapSessionsToClient: (sessions: DeviceSession[], fallbackDeviceId?: string, fallbackUserId?: string) => ClientSession[];
+/**
+ * Fetch device sessions with fallback to the legacy session endpoint when needed.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionId - Session identifier to fetch
+ * @param options - Optional fallback options
+ */
+export declare const fetchSessionsWithFallback: (oxyServices: OxyServicesAny, sessionId: string, { fallbackDeviceId, fallbackUserId, logger, }?: FetchSessionsWithFallbackOptions) => Promise<ClientSession[]>;
+/**
+ * Validate multiple sessions concurrently with configurable concurrency.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionIds - Session identifiers to validate
+ * @param options - Validation options
+ */
+export declare const validateSessionBatch: (oxyServices: OxyServicesAny, sessionIds: string[], { useHeaderValidation, maxConcurrency }?: ValidateSessionBatchOptions) => Promise<SessionValidationResult[]>;
+export {};

package/src/ui/utils/sessionHelpers.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSessionBatch = exports.fetchSessionsWithFallback = exports.mapSessionsToClient = void 0;
+/**
+ * Normalize backend session payloads into `ClientSession` objects.
+ *
+ * @param sessions - Raw session array returned from the API
+ * @param fallbackDeviceId - Device identifier to use when missing from payload
+ * @param fallbackUserId - User identifier to use when missing from payload
+ */
+const mapSessionsToClient = (sessions, fallbackDeviceId, fallbackUserId) => {
+    const now = new Date();
+    return sessions.map((session) => ({
+        sessionId: session.sessionId,
+        deviceId: session.deviceId || fallbackDeviceId || '',
+        expiresAt: session.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+        lastActive: session.lastActive || now.toISOString(),
+        userId: session.user?.id ||
+            session.userId ||
+            (session.user?._id ? session.user._id.toString() : undefined) ||
+            fallbackUserId ||
+            '',
+        isCurrent: Boolean(session.isCurrent),
+    }));
+};
+exports.mapSessionsToClient = mapSessionsToClient;
+/**
+ * Fetch device sessions with fallback to the legacy session endpoint when needed.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionId - Session identifier to fetch
+ * @param options - Optional fallback options
+ */
+const fetchSessionsWithFallback = async (oxyServices, sessionId, { fallbackDeviceId, fallbackUserId, logger, } = {}) => {
+    try {
+        const deviceSessions = await oxyServices.getDeviceSessions(sessionId);
+        return (0, exports.mapSessionsToClient)(deviceSessions, fallbackDeviceId, fallbackUserId);
+    }
+    catch (error) {
+        if (__DEV__ && logger) {
+            logger('Failed to get device sessions, falling back to user sessions', error);
+        }
+        const userSessions = await oxyServices.getSessionsBySessionId(sessionId);
+        return (0, exports.mapSessionsToClient)(userSessions, fallbackDeviceId, fallbackUserId);
+    }
+};
+exports.fetchSessionsWithFallback = fetchSessionsWithFallback;
+/**
+ * Validate multiple sessions concurrently with configurable concurrency.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionIds - Session identifiers to validate
+ * @param options - Validation options
+ */
+const validateSessionBatch = async (oxyServices, sessionIds, { useHeaderValidation = true, maxConcurrency = 5 } = {}) => {
+    if (!sessionIds.length) {
+        return [];
+    }
+    const uniqueSessionIds = Array.from(new Set(sessionIds));
+    const safeConcurrency = Math.max(1, Math.min(maxConcurrency, uniqueSessionIds.length));
+    const results = [];
+    let index = 0;
+    const worker = async () => {
+        while (index < uniqueSessionIds.length) {
+            const currentIndex = index;
+            index += 1;
+            const sessionId = uniqueSessionIds[currentIndex];
+            try {
+                const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation });
+                const valid = Boolean(validation?.valid);
+                results.push({
+                    sessionId,
+                    valid,
+                    user: validation?.user,
+                    raw: validation,
+                });
+            }
+            catch (error) {
+                results.push({
+                    sessionId,
+                    valid: false,
+                    error,
+                });
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: safeConcurrency }, worker));
+    return results;
+};
+exports.validateSessionBatch = validateSessionBatch;

package/src/ui/utils/storageHelpers.d.ts

@@ -0,0 +1,27 @@
+export interface StorageInterface {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+}
+export interface SessionStorageKeys {
+    activeSessionId: string;
+    sessionIds: string;
+    language: string;
+}
+/**
+ * Detect whether the current runtime is React Native.
+ */
+export declare const isReactNative: () => boolean;
+/**
+ * Create a platform-appropriate storage implementation.
+ * Defaults to in-memory storage when no platform storage is available.
+ */
+export declare const createPlatformStorage: () => Promise<StorageInterface>;
+export declare const STORAGE_KEY_PREFIX = "oxy_session";
+/**
+ * Produce strongly typed storage key names for the supplied prefix.
+ *
+ * @param prefix - Storage key prefix
+ */
+export declare const getStorageKeys: (prefix?: string) => SessionStorageKeys;