@lakshmiprasanth/react-voice-to-text/lib/hooks/useFileUpload.esm.js

A modern React package for voice-to-text conversion with real-time speech recognition and file upload support

import { useState, useCallback } from 'react';

const useFileUpload = (options = {}) => {
    const { acceptedFormats = ['audio/*'], maxFileSize = 50 * 1024 * 1024, // 50MB
    onFileSelect, onConvert, onError } = options;
    const [selectedFile, setSelectedFile] = useState(null);
    const [isConverting, setIsConverting] = useState(false);
    const [results, setResults] = useState([]);
    const [error, setError] = useState(null);
    const validateFile = useCallback((file) => {
        // Validate file size
        if (file.size > maxFileSize) {
            return {
                isValid: false,
                error: `File size (${(file.size / 1024 / 1024).toFixed(2)}MB) exceeds maximum allowed size (${(maxFileSize / 1024 / 1024).toFixed(2)}MB)`
            };
        }
        // Validate file type
        const isValidType = acceptedFormats.some(format => {
            if (format === 'audio/*') {
                return file.type.startsWith('audio/');
            }
            return file.type === format;
        });
        if (!isValidType) {
            return {
                isValid: false,
                error: `File type ${file.type} is not supported. Please select an audio file.`
            };
        }
        return { isValid: true };
    }, [acceptedFormats, maxFileSize]);
    const selectFile = useCallback((file) => {
        const validation = validateFile(file);
        if (!validation.isValid) {
            setError(validation.error || 'Unknown validation error');
            onError?.(validation.error);
            return;
        }
        setSelectedFile(file);
        setError(null);
        onFileSelect?.(file);
    }, [validateFile, onFileSelect, onError]);
    const convertFile = useCallback(async (language = 'en-US') => {
        if (!selectedFile) {
            const error = 'No file selected';
            setError(error);
            onError?.(error);
            return;
        }
        setIsConverting(true);
        setError(null);
        try {
            const result = await onConvert?.(selectedFile, language);
            if (result) {
                setResults(prev => [...prev, result]);
            }
        }
        catch (err) {
            const errorMessage = err instanceof Error ? err.message : 'Failed to convert file';
            setError(errorMessage);
            onError?.(errorMessage);
        }
        finally {
            setIsConverting(false);
        }
    }, [selectedFile, onConvert, onError]);
    const clearFile = useCallback(() => {
        setSelectedFile(null);
    }, []);
    const clearResults = useCallback(() => {
        setResults([]);
    }, []);
    const clearError = useCallback(() => {
        setError(null);
    }, []);
    return {
        selectedFile,
        isConverting,
        results,
        error,
        selectFile,
        convertFile,
        clearFile,
        clearResults,
        clearError,
        validateFile
    };
};

export { useFileUpload };
//# sourceMappingURL=useFileUpload.esm.js.map