@gofranz/formshive-submit 1.0.0

package/dist/formshive-submit.cjs

@@ -0,0 +1,1714 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * TypeScript type definitions for Formshive Submit library
+ */
+// Default configurations
+const DEFAULT_RETRY_CONFIG = {
+    maxAttempts: 3,
+    baseDelay: 1000,
+    maxDelay: 30000,
+    enableJitter: true,
+    backoffMultiplier: 2,
+};
+const DEFAULT_FILE_CONFIG = {
+    maxFileSize: 10 * 1024 * 1024, // 10MB
+    allowedTypes: [], // Empty array means allow all types
+    trackProgress: true,
+};
+const DEFAULT_OPTIONS = {
+    endpoint: 'https://api.formshive.com/v1',
+    httpClient: 'fetch',
+    timeout: 30000,
+    debug: false,
+    retry: DEFAULT_RETRY_CONFIG,
+    files: DEFAULT_FILE_CONFIG,
+};
+// Export error codes
+const ERROR_CODES = {
+    NETWORK_ERROR: 'NETWORK_ERROR',
+    TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    FILE_TOO_LARGE: 'FILE_TOO_LARGE',
+    INVALID_FILE_TYPE: 'INVALID_FILE_TYPE',
+    FORM_NOT_FOUND: 'FORM_NOT_FOUND',
+    SERVER_ERROR: 'SERVER_ERROR',
+    RATE_LIMITED: 'RATE_LIMITED',
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+};
+
+/**
+ * HTTP Client abstraction for both fetch and axios
+ */
+/**
+ * Fetch-based HTTP client adapter
+ */
+class FetchAdapter {
+    async request(config) {
+        const controller = new AbortController();
+        let timeoutId = null;
+        if (config.timeout) {
+            timeoutId = setTimeout(() => controller.abort(), config.timeout);
+        }
+        try {
+            const response = await fetch(config.url, {
+                method: config.method,
+                headers: {
+                    ...config.headers,
+                },
+                body: config.data,
+                signal: controller.signal,
+            });
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            // Convert headers to record
+            const headers = {};
+            response.headers.forEach((value, key) => {
+                headers[key] = value;
+            });
+            let data;
+            const contentType = response.headers.get('content-type');
+            if (contentType?.includes('application/json')) {
+                data = await response.json();
+            }
+            else {
+                data = await response.text();
+            }
+            return {
+                data,
+                status: response.status,
+                statusText: response.statusText,
+                headers,
+            };
+        }
+        catch (error) {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error('Request timeout');
+            }
+            throw error;
+        }
+    }
+    supportsProgress() {
+        // Note: fetch doesn't support upload progress natively
+        // This would require using streams which is complex
+        return false;
+    }
+}
+/**
+ * Axios-based HTTP client adapter
+ */
+class AxiosAdapter {
+    constructor(axiosInstance) {
+        this.axiosInstance = axiosInstance;
+    }
+    async request(config) {
+        try {
+            const response = await this.axiosInstance.request({
+                url: config.url,
+                method: config.method,
+                data: config.data,
+                headers: config.headers,
+                timeout: config.timeout,
+                onUploadProgress: config.onUploadProgress,
+            });
+            return {
+                data: response.data,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            };
+        }
+        catch (error) {
+            // Re-throw axios errors as they contain useful information
+            throw error;
+        }
+    }
+    supportsProgress() {
+        return true;
+    }
+}
+/**
+ * Create HTTP client adapter based on the provided client type
+ */
+function createHttpClient(client) {
+    if (typeof client === 'string') {
+        switch (client) {
+            case 'fetch':
+                return new FetchAdapter();
+            case 'axios':
+                // Try to import axios dynamically
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const axios = require('axios');
+                    return new AxiosAdapter(axios.create());
+                }
+                catch (error) {
+                    throw new Error('Axios is not available. Please install axios or use fetch client.');
+                }
+            default:
+                throw new Error(`Unsupported HTTP client: ${client}`);
+        }
+    }
+    else {
+        // Assume it's an Axios instance
+        return new AxiosAdapter(client);
+    }
+}
+/**
+ * Try to parse field validation errors from response data
+ */
+function parseFieldValidationErrors(responseData) {
+    if (!responseData || typeof responseData !== 'object') {
+        return {};
+    }
+    // Check if this is a Formshive field validation error response
+    if (responseData.error === 'validation_error' &&
+        Array.isArray(responseData.errors)) {
+        const validationResponse = responseData;
+        return {
+            fieldErrors: validationResponse.errors,
+            validationResponse: validationResponse
+        };
+    }
+    return {};
+}
+/**
+ * Create a SubmitError from various error types
+ */
+function createSubmitError(error, attempt, code = 'UNKNOWN_ERROR') {
+    let message = 'Unknown error';
+    let statusCode;
+    let response;
+    let isRetryable = true;
+    let fieldErrors;
+    let validationResponse;
+    // Handle axios errors
+    if (error.isAxiosError) {
+        const axiosError = error;
+        message = axiosError.message;
+        statusCode = axiosError.response?.status;
+        response = axiosError.response?.data;
+        // Parse field validation errors if this is a 400 response
+        if (statusCode === 400) {
+            const fieldValidation = parseFieldValidationErrors(response);
+            fieldErrors = fieldValidation.fieldErrors;
+            validationResponse = fieldValidation.validationResponse;
+            // Use more specific message from validation response
+            if (validationResponse?.message) {
+                message = validationResponse.message;
+            }
+        }
+        // Determine if error is retryable
+        if (statusCode) {
+            // Don't retry client errors except 429 (rate limiting)
+            if (statusCode >= 400 && statusCode < 500 && statusCode !== 429) {
+                isRetryable = false;
+            }
+            // Set appropriate error code
+            if (statusCode === 404) {
+                code = 'FORM_NOT_FOUND';
+            }
+            else if (statusCode === 429) {
+                code = 'RATE_LIMITED';
+            }
+            else if (statusCode >= 400 && statusCode < 500) {
+                code = 'VALIDATION_ERROR';
+            }
+            else if (statusCode >= 500) {
+                code = 'SERVER_ERROR';
+            }
+        }
+    }
+    // Handle fetch errors
+    else if (error instanceof Error) {
+        message = error.message;
+        if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+            code = 'TIMEOUT_ERROR';
+        }
+        else if (error.message.includes('network') || error.message.includes('fetch')) {
+            code = 'NETWORK_ERROR';
+        }
+    }
+    // Handle Response objects (from fetch)
+    else if (error instanceof Response) {
+        statusCode = error.status;
+        message = `HTTP ${error.status}: ${error.statusText}`;
+        // Try to extract response data for field validation errors
+        if (statusCode === 400) {
+            try {
+                // If response body is available, try to parse it
+                if (error.body) {
+                    error.json().then(data => {
+                        const fieldValidation = parseFieldValidationErrors(data);
+                        if (fieldValidation.validationResponse?.message) {
+                            message = fieldValidation.validationResponse.message;
+                        }
+                    }).catch(() => {
+                        // Ignore JSON parsing errors for Response objects
+                    });
+                }
+            }
+            catch (e) {
+                // Ignore parsing errors
+            }
+        }
+        // Determine if error is retryable
+        if (statusCode >= 400 && statusCode < 500 && statusCode !== 429) {
+            isRetryable = false;
+        }
+        // Set appropriate error code
+        if (statusCode === 404) {
+            code = 'FORM_NOT_FOUND';
+        }
+        else if (statusCode === 429) {
+            code = 'RATE_LIMITED';
+        }
+        else if (statusCode >= 400 && statusCode < 500) {
+            code = 'VALIDATION_ERROR';
+        }
+        else if (statusCode >= 500) {
+            code = 'SERVER_ERROR';
+        }
+    }
+    const submitError = new Error(message);
+    submitError.name = 'SubmitError';
+    submitError.code = ERROR_CODES[code];
+    submitError.statusCode = statusCode || undefined;
+    submitError.response = response;
+    submitError.attempt = attempt;
+    submitError.isRetryable = isRetryable;
+    submitError.originalError = error;
+    submitError.fieldErrors = fieldErrors;
+    submitError.validationResponse = validationResponse;
+    return submitError;
+}
+/**
+ * Check if an error is retryable
+ */
+function isRetryableError(error) {
+    // Network errors are retryable
+    if (error instanceof TypeError && error.message.includes('fetch')) {
+        return true;
+    }
+    // Timeout errors are retryable
+    if (error.message?.includes('timeout') || error.message?.includes('Timeout')) {
+        return true;
+    }
+    // Server errors (5xx) are retryable
+    if (error.response?.status >= 500) {
+        return true;
+    }
+    // Rate limiting (429) is retryable
+    if (error.response?.status === 429) {
+        return true;
+    }
+    // Axios network errors are retryable
+    if (error.isAxiosError && !error.response) {
+        return true;
+    }
+    // Client errors (4xx except 429) are not retryable
+    if (error.response?.status >= 400 && error.response?.status < 500 && error.response?.status !== 429) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Get user-friendly error message based on error type
+ */
+function getErrorMessage(error) {
+    switch (error.code) {
+        case ERROR_CODES.FORM_NOT_FOUND:
+            return 'Form not found. Please check the form ID.';
+        case ERROR_CODES.VALIDATION_ERROR:
+            return error.response?.message || 'Form validation failed. Please check your data.';
+        case ERROR_CODES.FILE_TOO_LARGE:
+            return 'One or more files are too large. Please reduce file size and try again.';
+        case ERROR_CODES.INVALID_FILE_TYPE:
+            return 'Invalid file type. Please check allowed file types.';
+        case ERROR_CODES.RATE_LIMITED:
+            return 'Too many requests. Please wait a moment and try again.';
+        case ERROR_CODES.TIMEOUT_ERROR:
+            return 'Request timed out. Please check your connection and try again.';
+        case ERROR_CODES.NETWORK_ERROR:
+            return 'Network error. Please check your internet connection.';
+        case ERROR_CODES.SERVER_ERROR:
+            return 'Server error. Please try again in a few minutes.';
+        default:
+            return error.message || 'An unexpected error occurred.';
+    }
+}
+
+/**
+ * Retry mechanism with exponential backoff and jitter
+ */
+/**
+ * Sleep utility for retry delays
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Calculate delay with exponential backoff and optional jitter
+ */
+function calculateDelay(attempt, config) {
+    const exponentialDelay = config.baseDelay * Math.pow(config.backoffMultiplier, attempt - 1);
+    // Apply maximum delay limit
+    const cappedDelay = Math.min(exponentialDelay, config.maxDelay);
+    // Add jitter to avoid thundering herd problem
+    if (config.enableJitter) {
+        // Random jitter between 0% and 25% of the delay
+        const jitterRange = cappedDelay * 0.25;
+        const jitter = Math.random() * jitterRange;
+        return Math.floor(cappedDelay + jitter);
+    }
+    return cappedDelay;
+}
+/**
+ * Retry function with exponential backoff
+ */
+async function withRetry(operation, config = {}, logger, onRetry) {
+    const finalConfig = {
+        ...DEFAULT_RETRY_CONFIG,
+        ...config,
+    };
+    let lastError;
+    for (let attempt = 1; attempt <= finalConfig.maxAttempts; attempt++) {
+        try {
+            logger?.debug(`Attempt ${attempt}/${finalConfig.maxAttempts}`);
+            const result = await operation();
+            if (attempt > 1) {
+                logger?.info(`Operation succeeded on attempt ${attempt}`);
+            }
+            return result;
+        }
+        catch (error) {
+            lastError = error;
+            logger?.warn(`Attempt ${attempt} failed:`, error.message);
+            // Check if this is the last attempt
+            if (attempt === finalConfig.maxAttempts) {
+                logger?.error(`All ${finalConfig.maxAttempts} attempts failed. Giving up.`);
+                break;
+            }
+            // Check if error is retryable
+            if (!isRetryableError(error)) {
+                logger?.info('Error is not retryable. Stopping retry attempts.');
+                break;
+            }
+            // Calculate delay for next attempt
+            const delay = calculateDelay(attempt, finalConfig);
+            logger?.debug(`Waiting ${delay}ms before next attempt...`);
+            // Call retry callback if provided
+            if (onRetry) {
+                try {
+                    onRetry(attempt, finalConfig.maxAttempts, error);
+                }
+                catch (callbackError) {
+                    logger?.warn('Retry callback threw an error:', callbackError);
+                }
+            }
+            // Wait before next attempt
+            await sleep(delay);
+        }
+    }
+    // All attempts failed
+    throw lastError;
+}
+/**
+ * Create a retry-enabled version of a function
+ */
+function createRetryableFunction(fn, config = {}, logger) {
+    return async (...args) => {
+        return withRetry(() => fn(...args), config, logger);
+    };
+}
+/**
+ * Smart retry decorator that can be used with different error types
+ */
+class RetryManager {
+    constructor(config = {}, logger) {
+        this.config = { ...DEFAULT_RETRY_CONFIG, ...config };
+        this.logger = logger;
+    }
+    /**
+     * Execute operation with retry logic
+     */
+    async execute(operation, onRetry) {
+        return withRetry(operation, this.config, this.logger, onRetry);
+    }
+    /**
+     * Update retry configuration
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Check if an attempt should be retried based on attempt number and error
+     */
+    shouldRetry(attempt, error) {
+        if (attempt >= this.config.maxAttempts) {
+            return false;
+        }
+        return isRetryableError(error);
+    }
+    /**
+     * Calculate the delay for a specific attempt
+     */
+    getDelay(attempt) {
+        return calculateDelay(attempt, this.config);
+    }
+}
+/**
+ * Utility to create common retry configurations
+ */
+const RetryPresets = {
+    /**
+     * Quick retry for fast operations
+     */
+    quick: () => ({
+        maxAttempts: 2,
+        baseDelay: 500,
+        maxDelay: 2000,
+        enableJitter: true,
+        backoffMultiplier: 2,
+    }),
+    /**
+     * Standard retry for most operations
+     */
+    standard: () => ({
+        ...DEFAULT_RETRY_CONFIG,
+    }),
+    /**
+     * Patient retry for heavy operations
+     */
+    patient: () => ({
+        maxAttempts: 5,
+        baseDelay: 2000,
+        maxDelay: 60000,
+        enableJitter: true,
+        backoffMultiplier: 1.5,
+    }),
+    /**
+     * Aggressive retry for critical operations
+     */
+    aggressive: () => ({
+        maxAttempts: 10,
+        baseDelay: 100,
+        maxDelay: 30000,
+        enableJitter: true,
+        backoffMultiplier: 1.8,
+    }),
+    /**
+     * Custom retry configuration
+     */
+    custom: (overrides) => ({
+        ...DEFAULT_RETRY_CONFIG,
+        ...overrides,
+    }),
+};
+/**
+ * Utility function to get delay information for display purposes
+ */
+function getRetryDelayInfo(attempt, config = {}) {
+    const finalConfig = {
+        ...DEFAULT_RETRY_CONFIG,
+        ...config,
+    };
+    let totalElapsed = 0;
+    for (let i = 1; i < attempt; i++) {
+        totalElapsed += calculateDelay(i, finalConfig);
+    }
+    const delay = calculateDelay(attempt, finalConfig);
+    return { delay, totalElapsed };
+}
+
+/**
+ * File handling and validation utilities
+ */
+/**
+ * Validate file against configuration rules
+ */
+function validateFile(file, config) {
+    // Check file size
+    if (file.size > config.maxFileSize) {
+        return `File "${file.name}" is too large. Maximum size is ${formatFileSize(config.maxFileSize)}, but file is ${formatFileSize(file.size)}.`;
+    }
+    // Check file type if restrictions are set
+    if (config.allowedTypes.length > 0) {
+        const isAllowed = config.allowedTypes.some(allowedType => {
+            // Handle wildcard types like "image/*"
+            if (allowedType.includes('*')) {
+                const baseType = allowedType.split('/')[0];
+                return file.type.startsWith(baseType + '/');
+            }
+            // Handle exact type matches
+            return file.type === allowedType;
+        });
+        if (!isAllowed) {
+            return `File "${file.name}" has unsupported type "${file.type}". Allowed types: ${config.allowedTypes.join(', ')}.`;
+        }
+    }
+    return null; // File is valid
+}
+/**
+ * Format file size for human-readable display
+ */
+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 parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+/**
+ * Extract files from form data object
+ */
+function extractFiles(data) {
+    const files = [];
+    function processValue(key, value) {
+        if (value instanceof File) {
+            files.push({
+                field: key,
+                file: value,
+                name: value.name,
+                size: value.size,
+                type: value.type,
+            });
+        }
+        else if (value instanceof FileList) {
+            // Handle multiple files from input[type="file"][multiple]
+            for (let i = 0; i < value.length; i++) {
+                const file = value.item(i);
+                if (file) {
+                    files.push({
+                        field: `${key}[${i}]`,
+                        file,
+                        name: file.name,
+                        size: file.size,
+                        type: file.type,
+                    });
+                }
+            }
+        }
+        else if (Array.isArray(value)) {
+            // Handle array of files
+            value.forEach((item, index) => {
+                if (item instanceof File) {
+                    files.push({
+                        field: `${key}[${index}]`,
+                        file: item,
+                        name: item.name,
+                        size: item.size,
+                        type: item.type,
+                    });
+                }
+            });
+        }
+    }
+    // Process all form fields
+    for (const [key, value] of Object.entries(data)) {
+        processValue(key, value);
+    }
+    return files;
+}
+/**
+ * Validate all files in a collection
+ */
+function validateFiles(files, config, logger) {
+    const errors = [];
+    for (const fileInfo of files) {
+        logger?.debug(`Validating file: ${fileInfo.name} (${formatFileSize(fileInfo.size)}, ${fileInfo.type})`);
+        const error = validateFile(fileInfo.file, config);
+        if (error) {
+            errors.push(error);
+            logger?.warn(`File validation failed: ${error}`);
+        }
+    }
+    return errors;
+}
+/**
+ * Process form data and handle files
+ */
+function processFormData(inputData, fileConfig = {}, logger) {
+    const config = { ...DEFAULT_FILE_CONFIG, ...fileConfig };
+    // If input is already FormData, extract information from it
+    if (inputData instanceof FormData) {
+        const files = [];
+        // Process FormData entries
+        for (const [key, value] of inputData.entries()) {
+            if (value instanceof File) {
+                files.push({
+                    field: key,
+                    file: value,
+                    name: value.name,
+                    size: value.size,
+                    type: value.type,
+                });
+            }
+        }
+        // Validate files
+        const validationErrors = validateFiles(files, config, logger);
+        if (validationErrors.length > 0) {
+            const error = new Error(validationErrors.join(' '));
+            error.name = 'SubmitError';
+            error.code = ERROR_CODES.FILE_TOO_LARGE; // Could be file size or type error
+            error.attempt = 0;
+            error.isRetryable = false;
+            throw error;
+        }
+        return {
+            data: inputData,
+            hasFiles: files.length > 0,
+            files,
+        };
+    }
+    // Handle object data
+    const files = extractFiles(inputData);
+    const hasFiles = files.length > 0;
+    logger?.debug(`Found ${files.length} files in form data`);
+    // Validate files
+    if (hasFiles) {
+        const validationErrors = validateFiles(files, config, logger);
+        if (validationErrors.length > 0) {
+            const error = new Error(validationErrors.join(' '));
+            error.name = 'SubmitError';
+            error.code = validationErrors[0]?.includes('too large')
+                ? ERROR_CODES.FILE_TOO_LARGE
+                : ERROR_CODES.INVALID_FILE_TYPE;
+            error.attempt = 0;
+            error.isRetryable = false;
+            throw error;
+        }
+    }
+    // Convert to FormData if files are present
+    let processedData;
+    if (hasFiles) {
+        logger?.debug('Converting to FormData due to file presence');
+        processedData = new FormData();
+        // Add all non-file fields
+        for (const [key, value] of Object.entries(inputData)) {
+            if (!(value instanceof File) && !(value instanceof FileList) && !Array.isArray(value)) {
+                // Handle simple values
+                if (value !== undefined && value !== null) {
+                    processedData.append(key, String(value));
+                }
+            }
+            else if (Array.isArray(value)) {
+                // Handle arrays (might contain files or other values)
+                value.forEach((item, index) => {
+                    if (item instanceof File) {
+                        processedData.append(`${key}[${index}]`, item);
+                    }
+                    else if (item !== undefined && item !== null) {
+                        processedData.append(`${key}[${index}]`, String(item));
+                    }
+                });
+            }
+            else if (value instanceof File) {
+                processedData.append(key, value);
+            }
+            else if (value instanceof FileList) {
+                for (let i = 0; i < value.length; i++) {
+                    const file = value.item(i);
+                    if (file) {
+                        processedData.append(`${key}[${i}]`, file);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // No files, keep as object (will be sent as JSON)
+        logger?.debug('No files found, keeping as object for JSON submission');
+        processedData = { ...inputData };
+    }
+    return {
+        data: processedData,
+        hasFiles,
+        files,
+    };
+}
+/**
+ * Create progress tracker for file uploads
+ */
+function createProgressTracker(files, onProgress) {
+    const totalSize = files.reduce((sum, file) => sum + file.size, 0);
+    if (!onProgress || totalSize === 0) {
+        return undefined;
+    }
+    return (progressEvent) => {
+        if (progressEvent.lengthComputable) {
+            const percent = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+            onProgress(percent, progressEvent.loaded, progressEvent.total);
+        }
+    };
+}
+/**
+ * Get MIME type from file extension (fallback if browser doesn't detect)
+ */
+function getMimeTypeFromExtension(filename) {
+    const extension = filename.split('.').pop()?.toLowerCase();
+    const mimeTypes = {
+        // Images
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        png: 'image/png',
+        gif: 'image/gif',
+        webp: 'image/webp',
+        svg: 'image/svg+xml',
+        // Documents
+        pdf: 'application/pdf',
+        doc: 'application/msword',
+        docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        xls: 'application/vnd.ms-excel',
+        xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        ppt: 'application/vnd.ms-powerpoint',
+        pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        // Text
+        txt: 'text/plain',
+        csv: 'text/csv',
+        json: 'application/json',
+        xml: 'application/xml',
+        // Archives
+        zip: 'application/zip',
+        rar: 'application/x-rar-compressed',
+        '7z': 'application/x-7z-compressed',
+        // Audio
+        mp3: 'audio/mpeg',
+        wav: 'audio/wav',
+        ogg: 'audio/ogg',
+        // Video
+        mp4: 'video/mp4',
+        avi: 'video/x-msvideo',
+        mov: 'video/quicktime',
+        wmv: 'video/x-ms-wmv',
+    };
+    return extension ? mimeTypes[extension] || null : null;
+}
+/**
+ * Enhanced file information with additional metadata
+ */
+function getEnhancedFileInfo(file) {
+    const extension = file.name.split('.').pop()?.toLowerCase() || '';
+    const detectedMimeType = getMimeTypeFromExtension(file.name);
+    return {
+        field: '', // Will be set by caller
+        file,
+        name: file.name,
+        size: file.size,
+        type: file.type,
+        extension,
+        detectedMimeType,
+        isImage: file.type.startsWith('image/'),
+        isDocument: file.type.includes('pdf') || file.type.includes('document') || file.type.includes('word') || file.type.includes('excel') || file.type.includes('powerpoint'),
+        isArchive: file.type.includes('zip') || file.type.includes('rar') || file.type.includes('7z'),
+    };
+}
+
+/**
+ * Utility functions and logging
+ */
+/**
+ * Simple console-based logger implementation
+ */
+class ConsoleLogger {
+    constructor(enabled = false) {
+        this.enabled = enabled;
+    }
+    debug(message, ...args) {
+        if (this.enabled) {
+            console.debug('[FormshiveSubmit DEBUG]', message, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.enabled) {
+            console.info('[FormshiveSubmit INFO]', message, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.enabled) {
+            console.warn('[FormshiveSubmit WARN]', message, ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.enabled) {
+            console.error('[FormshiveSubmit ERROR]', message, ...args);
+        }
+    }
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+}
+/**
+ * No-op logger for production builds
+ */
+class NoOpLogger {
+    debug() { }
+    info() { }
+    warn() { }
+    error() { }
+}
+/**
+ * Create logger based on debug flag
+ */
+function createLogger(debug = false) {
+    return debug ? new ConsoleLogger(true) : new NoOpLogger();
+}
+/**
+ * Validate URL format
+ */
+function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure URL has protocol
+ */
+function ensureProtocol(url) {
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+        return `https://${url}`;
+    }
+    return url;
+}
+/**
+ * Build form submission URL
+ */
+function buildSubmissionUrl(endpoint, formId) {
+    const baseUrl = ensureProtocol(endpoint);
+    const trimmedUrl = baseUrl.replace(/\/$/, '');
+    return `${trimmedUrl}/digest/${encodeURIComponent(formId)}`;
+}
+/**
+ * Generate unique request ID for tracking
+ */
+function generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+/**
+ * Format duration in milliseconds to human readable string
+ */
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    else if (ms < 60000) {
+        return `${(ms / 1000).toFixed(1)}s`;
+    }
+    else {
+        const minutes = Math.floor(ms / 60000);
+        const seconds = ((ms % 60000) / 1000).toFixed(0);
+        return `${minutes}m ${seconds}s`;
+    }
+}
+/**
+ * Deep clone object (simple implementation)
+ */
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof Array) {
+        return obj.map(item => deepClone(item));
+    }
+    if (typeof obj === 'object') {
+        const cloned = {};
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                cloned[key] = deepClone(obj[key]);
+            }
+        }
+        return cloned;
+    }
+    return obj;
+}
+/**
+ * Safely get nested object property
+ */
+function getNestedProperty(obj, path) {
+    return path.split('.').reduce((current, key) => {
+        return current && current[key] !== undefined ? current[key] : undefined;
+    }, obj);
+}
+/**
+ * Debounce function
+ */
+function debounce(func, wait) {
+    let timeout = null;
+    return (...args) => {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(() => func(...args), wait);
+    };
+}
+/**
+ * Throttle function
+ */
+function throttle(func, limit) {
+    let inThrottle = false;
+    return (...args) => {
+        if (!inThrottle) {
+            func(...args);
+            inThrottle = true;
+            setTimeout(() => (inThrottle = false), limit);
+        }
+    };
+}
+/**
+ * Check if running in browser environment
+ */
+function isBrowser() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+/**
+ * Check if fetch is available
+ */
+function isFetchAvailable() {
+    return typeof fetch !== 'undefined';
+}
+/**
+ * Check if FormData is available
+ */
+function isFormDataAvailable() {
+    return typeof FormData !== 'undefined';
+}
+/**
+ * Get environment info for debugging
+ */
+function getEnvironmentInfo() {
+    const userAgent = isBrowser() ? navigator.userAgent : undefined;
+    return {
+        browser: isBrowser(),
+        fetch: isFetchAvailable(),
+        formData: isFormDataAvailable(),
+        userAgent,
+    };
+}
+/**
+ * Parse error message from various error types
+ */
+function parseErrorMessage(error) {
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error && typeof error === 'object') {
+        // Check for common error properties
+        if (error.message) {
+            return String(error.message);
+        }
+        if (error.error) {
+            return String(error.error);
+        }
+        if (error.statusText) {
+            return String(error.statusText);
+        }
+        // Try to stringify if it's an object
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return 'Unknown error';
+        }
+    }
+    return 'Unknown error';
+}
+/**
+ * Sanitize string for logging (remove sensitive information)
+ */
+function sanitizeForLogging(input) {
+    // Remove potential passwords, tokens, keys, etc.
+    return input
+        .replace(/password[^&\s]*=[^&\s]*/gi, 'password=***')
+        .replace(/token[^&\s]*=[^&\s]*/gi, 'token=***')
+        .replace(/key[^&\s]*=[^&\s]*/gi, 'key=***')
+        .replace(/secret[^&\s]*=[^&\s]*/gi, 'secret=***')
+        .replace(/authorization:\s*[^\s]+/gi, 'authorization: ***');
+}
+/**
+ * Create a timeout promise that rejects after specified time
+ */
+function createTimeoutPromise(ms) {
+    return new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error(`Operation timed out after ${ms}ms`));
+        }, ms);
+    });
+}
+/**
+ * Race a promise against a timeout
+ */
+function withTimeout(promise, ms) {
+    return Promise.race([
+        promise,
+        createTimeoutPromise(ms)
+    ]);
+}
+/**
+ * Retry a promise with simple linear backoff
+ */
+async function simpleRetry(fn, maxRetries = 3, delay = 1000) {
+    let lastError;
+    for (let i = 0; i <= maxRetries; i++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (i < maxRetries) {
+                await new Promise(resolve => setTimeout(resolve, delay * (i + 1)));
+            }
+        }
+    }
+    throw lastError;
+}
+/**
+ * Convert object to query string
+ */
+function objectToQueryString(obj) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== undefined && value !== null) {
+            params.append(key, String(value));
+        }
+    }
+    return params.toString();
+}
+/**
+ * Merge objects with deep merging for nested objects
+ */
+function mergeObjects(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (source) {
+        for (const key in source) {
+            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                if (!target[key]) {
+                    Object.assign(target, { [key]: {} });
+                }
+                mergeObjects(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeObjects(target, ...sources);
+}
+
+/**
+ * Main form submission functionality
+ */
+/**
+ * Main form submission function
+ */
+async function submitForm(options) {
+    // Validate required options
+    if (!options.formId) {
+        throw new Error('formId is required');
+    }
+    if (!options.data) {
+        throw new Error('data is required');
+    }
+    // Merge with defaults
+    const config = { ...DEFAULT_OPTIONS, ...options };
+    // Create logger
+    const logger = createLogger(config.debug);
+    // Generate unique request ID for tracking
+    const requestId = generateRequestId();
+    const startTime = Date.now();
+    logger.info(`Starting form submission (${requestId})`, {
+        formId: config.formId,
+        endpoint: config.endpoint,
+        hasFiles: config.data instanceof FormData,
+        environment: getEnvironmentInfo(),
+    });
+    // Validate endpoint URL
+    if (!isValidUrl(config.endpoint)) {
+        const error = new Error(`Invalid endpoint URL: ${config.endpoint}`);
+        error.name = 'SubmitError';
+        error.code = ERROR_CODES.VALIDATION_ERROR;
+        error.attempt = 0;
+        error.isRetryable = false;
+        throw error;
+    }
+    try {
+        // Create HTTP client
+        const httpClient = createHttpClient(config.httpClient);
+        logger.debug('HTTP client created', {
+            type: typeof config.httpClient === 'string' ? config.httpClient : 'custom',
+            supportsProgress: httpClient.supportsProgress(),
+        });
+        // Process form data and handle files
+        const processedData = processFormData(config.data, config.files, logger);
+        logger.debug('Form data processed', {
+            hasFiles: processedData.hasFiles,
+            fileCount: processedData.files.length,
+            totalFileSize: processedData.files.reduce((sum, f) => sum + f.size, 0),
+        });
+        // Build submission URL
+        const submissionUrl = buildSubmissionUrl(config.endpoint, config.formId);
+        logger.debug(`Submission URL: ${submissionUrl}`);
+        // Prepare request configuration
+        const requestConfig = {
+            url: submissionUrl,
+            method: 'POST',
+            data: processedData.data,
+            headers: {
+                ...config.headers,
+            },
+            timeout: config.timeout || 30000,
+        };
+        // Set appropriate content type if not manually specified
+        if (!requestConfig.headers['Content-Type'] && !processedData.hasFiles) {
+            requestConfig.headers['Content-Type'] = 'application/json';
+            // Convert object to JSON string for non-multipart requests
+            if (!(processedData.data instanceof FormData)) {
+                requestConfig.data = JSON.stringify(processedData.data);
+            }
+        }
+        // Set up progress tracking for file uploads
+        if (processedData.hasFiles && httpClient.supportsProgress() && config.callbacks?.onProgress) {
+            const progressTracker = createProgressTracker(processedData.files, config.callbacks.onProgress);
+            if (progressTracker) {
+                requestConfig.onUploadProgress = progressTracker;
+                logger.debug('Progress tracking enabled for file upload');
+            }
+        }
+        // Call onStart callback
+        if (config.callbacks?.onStart) {
+            try {
+                config.callbacks.onStart();
+            }
+            catch (callbackError) {
+                logger.warn('onStart callback error:', callbackError);
+            }
+        }
+        // Create the submission function with retry logic
+        const submitWithRetry = async () => {
+            return withRetry(async () => {
+                logger.debug('Making HTTP request...');
+                const response = await httpClient.request(requestConfig);
+                const duration = Date.now() - startTime;
+                logger.info(`Form submission successful (${requestId})`, {
+                    statusCode: response.status,
+                    duration: formatDuration(duration),
+                });
+                // Prepare successful response
+                const submitResponse = {
+                    success: true,
+                    data: response.data,
+                    statusCode: response.status,
+                    headers: response.headers,
+                    attempt: 1, // Will be updated by retry logic
+                    duration,
+                };
+                // Check for redirect URL in response
+                if (response.headers['location']) {
+                    submitResponse.redirectUrl = response.headers['location'];
+                }
+                else if (response.data && typeof response.data === 'object' && response.data.redirect_url) {
+                    submitResponse.redirectUrl = response.data.redirect_url;
+                }
+                return submitResponse;
+            }, config.retry, logger, (attempt, maxAttempts, error) => {
+                logger.warn(`Retry attempt ${attempt}/${maxAttempts}:`, error.message);
+                // Call retry callback
+                if (config.callbacks?.onRetry) {
+                    try {
+                        config.callbacks.onRetry(attempt, maxAttempts, error);
+                    }
+                    catch (callbackError) {
+                        logger.warn('onRetry callback error:', callbackError);
+                    }
+                }
+            });
+        };
+        // Execute submission with retry
+        const result = await submitWithRetry();
+        // Update attempt count (this would be set by the retry mechanism)
+        // For now, we'll estimate based on timing or assume success on attempt 1
+        result.attempt = 1; // This should be provided by the retry mechanism
+        // Call success callback
+        if (config.callbacks?.onSuccess) {
+            try {
+                config.callbacks.onSuccess(result);
+            }
+            catch (callbackError) {
+                logger.warn('onSuccess callback error:', callbackError);
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        // Convert error to SubmitError if it isn't already
+        let submitError;
+        if (error.name === 'SubmitError') {
+            submitError = error;
+        }
+        else {
+            submitError = createSubmitError(error, 1); // Default to attempt 1
+        }
+        // Add duration and request ID for debugging
+        submitError.message = `${submitError.message} (${requestId}, ${formatDuration(duration)})`;
+        logger.error(`Form submission failed (${requestId})`, {
+            error: submitError.code,
+            message: submitError.message,
+            statusCode: submitError.statusCode,
+            duration: formatDuration(duration),
+            isRetryable: submitError.isRetryable,
+        });
+        // Call error callback
+        if (config.callbacks?.onError) {
+            try {
+                config.callbacks.onError(submitError);
+            }
+            catch (callbackError) {
+                logger.warn('onError callback error:', callbackError);
+            }
+        }
+        throw submitError;
+    }
+}
+/**
+ * Simplified form submission function with common defaults
+ */
+async function submitFormSimple(formId, data, options = {}) {
+    return submitForm({
+        formId,
+        data,
+        ...options,
+    });
+}
+/**
+ * Submit form with success/error callbacks in a more functional style
+ */
+function submitFormWithCallbacks(options, onSuccess, onError) {
+    const config = {
+        ...options,
+        callbacks: {
+            ...options.callbacks,
+            onSuccess: onSuccess || options.callbacks?.onSuccess,
+            onError: onError || options.callbacks?.onError,
+        },
+    };
+    return submitForm(config);
+}
+/**
+ * Create a reusable form submitter with pre-configured options
+ */
+class FormSubmitter {
+    constructor(defaultOptions = {}) {
+        this.defaultOptions = defaultOptions;
+        this.logger = createLogger(defaultOptions.debug);
+    }
+    /**
+     * Submit a form using the default configuration
+     */
+    async submit(formId, data, overrideOptions = {}) {
+        const baseOptions = { formId, data };
+        const options = {
+            ...this.defaultOptions,
+            ...baseOptions,
+            ...overrideOptions
+        };
+        return submitForm(options);
+    }
+    /**
+     * Update default options
+     */
+    updateDefaults(newDefaults) {
+        this.defaultOptions = { ...this.defaultOptions, ...newDefaults };
+        this.logger = createLogger(this.defaultOptions.debug || false);
+    }
+    /**
+     * Get current default options
+     */
+    getDefaults() {
+        return { ...this.defaultOptions };
+    }
+    /**
+     * Test connection to the API endpoint
+     */
+    async testConnection(endpoint) {
+        const testEndpoint = endpoint || this.defaultOptions.endpoint || DEFAULT_OPTIONS.endpoint;
+        try {
+            const httpClient = createHttpClient(this.defaultOptions.httpClient || 'fetch');
+            // Try to make a simple request to the base endpoint
+            await httpClient.request({
+                url: testEndpoint,
+                method: 'GET',
+                timeout: 5000,
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger.debug('Connection test failed:', error);
+            return false;
+        }
+    }
+}
+/**
+ * Utility to validate form data before submission
+ */
+function validateFormData(data) {
+    const errors = [];
+    const warnings = [];
+    if (!data) {
+        errors.push('Form data is required');
+        return { isValid: false, errors, warnings };
+    }
+    // Check for common issues
+    if (data instanceof FormData) {
+        let hasData = false;
+        for (const [key, value] of data.entries()) {
+            hasData = true;
+            if (typeof value === 'string' && value.trim() === '') {
+                warnings.push(`Field '${key}' is empty`);
+            }
+        }
+        if (!hasData) {
+            errors.push('FormData contains no fields');
+        }
+    }
+    else {
+        const keys = Object.keys(data);
+        if (keys.length === 0) {
+            errors.push('Form data object is empty');
+        }
+        // Check for potential issues
+        keys.forEach(key => {
+            const value = data[key];
+            if (value === null || value === undefined) {
+                warnings.push(`Field '${key}' is null or undefined`);
+            }
+            else if (typeof value === 'string' && value.trim() === '') {
+                warnings.push(`Field '${key}' is empty`);
+            }
+            else if (typeof value === 'object' && !(value instanceof File) && !(value instanceof FileList)) {
+                warnings.push(`Field '${key}' contains complex object - may not be serialized correctly`);
+            }
+        });
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+
+/**
+ * Field validation error handling utilities
+ */
+/**
+ * Check if an error contains field validation errors
+ */
+function isFieldValidationError(error) {
+    return !!(error.fieldErrors && error.fieldErrors.length > 0);
+}
+/**
+ * Get all field validation errors from a SubmitError
+ */
+function getFieldErrors(error) {
+    return error.fieldErrors || [];
+}
+/**
+ * Get validation error for a specific field
+ */
+function getFieldError(error, fieldName) {
+    const fieldErrors = getFieldErrors(error);
+    return fieldErrors.find(err => err.field === fieldName) || null;
+}
+/**
+ * Check if a specific field has validation errors
+ */
+function hasFieldError(error, fieldName) {
+    return getFieldError(error, fieldName) !== null;
+}
+/**
+ * Get all field names that have validation errors
+ */
+function getErrorFieldNames(error) {
+    const fieldErrors = getFieldErrors(error);
+    return fieldErrors.map(err => err.field);
+}
+/**
+ * Get validation response if available
+ */
+function getValidationResponse(error) {
+    return error.validationResponse || null;
+}
+/**
+ * Format field errors into a simple object for easy UI consumption
+ */
+function formatFieldErrors(error) {
+    const fieldErrors = getFieldErrors(error);
+    const formatted = {};
+    fieldErrors.forEach(err => {
+        formatted[err.field] = err.message;
+    });
+    return formatted;
+}
+/**
+ * Format field errors with codes for advanced error handling
+ */
+function formatFieldErrorsWithCodes(error) {
+    const fieldErrors = getFieldErrors(error);
+    const formatted = {};
+    fieldErrors.forEach(err => {
+        formatted[err.field] = err;
+    });
+    return formatted;
+}
+/**
+ * Get a human-readable summary of validation errors
+ */
+function getValidationErrorSummary(error) {
+    if (!isFieldValidationError(error)) {
+        return error.message || 'Validation error occurred';
+    }
+    const validationResponse = getValidationResponse(error);
+    if (validationResponse?.message) {
+        return validationResponse.message;
+    }
+    const fieldErrors = getFieldErrors(error);
+    if (fieldErrors.length === 1) {
+        return `${fieldErrors[0].field}: ${fieldErrors[0].message}`;
+    }
+    else if (fieldErrors.length > 1) {
+        const fieldNames = fieldErrors.map(err => err.field).join(', ');
+        return `Validation failed for fields: ${fieldNames}`;
+    }
+    return 'Form validation failed';
+}
+/**
+ * Create a map of field names to their error messages for easy form field highlighting
+ */
+function createFieldErrorMap(error) {
+    const fieldErrors = getFieldErrors(error);
+    const errorMap = new Map();
+    fieldErrors.forEach(err => {
+        errorMap.set(err.field, err.message);
+    });
+    return errorMap;
+}
+/**
+ * Get the first field error (useful for focusing on the first invalid field)
+ */
+function getFirstFieldError(error) {
+    const fieldErrors = getFieldErrors(error);
+    return fieldErrors.length > 0 ? fieldErrors[0] : null;
+}
+/**
+ * Check if validation errors include specific error codes
+ */
+function hasErrorCode(error, code) {
+    const fieldErrors = getFieldErrors(error);
+    return fieldErrors.some(err => err.code === code);
+}
+/**
+ * Check if a specific field has a specific error code
+ */
+function hasFieldErrorCode(error, fieldName, code) {
+    const fieldError = getFieldError(error, fieldName);
+    return fieldError?.code === code;
+}
+/**
+ * Get all errors with a specific code
+ */
+function getErrorsByCode(error, code) {
+    const fieldErrors = getFieldErrors(error);
+    return fieldErrors.filter(err => err.code === code);
+}
+/**
+ * Group errors by their error codes
+ */
+function groupErrorsByCode(error) {
+    const fieldErrors = getFieldErrors(error);
+    const grouped = {};
+    fieldErrors.forEach(err => {
+        if (!grouped[err.code]) {
+            grouped[err.code] = [];
+        }
+        grouped[err.code].push(err);
+    });
+    return grouped;
+}
+/**
+ * Create field error helpers for easy UI integration
+ */
+function createFieldErrorHelpers(error, defaultErrorClass = 'error') {
+    return {
+        getMessage: (fieldName) => {
+            if (!error)
+                return '';
+            const fieldError = getFieldError(error, fieldName);
+            return fieldError?.message || '';
+        },
+        hasError: (fieldName) => {
+            if (!error)
+                return false;
+            return hasFieldError(error, fieldName);
+        },
+        getFieldClass: (fieldName, errorClass) => {
+            if (!error)
+                return '';
+            const hasError = hasFieldError(error, fieldName);
+            return hasError ? (errorClass || defaultErrorClass) : '';
+        },
+        getError: (fieldName) => {
+            if (!error)
+                return null;
+            return getFieldError(error, fieldName);
+        }
+    };
+}
+/**
+ * Extract field validation errors from any error object
+ * Useful when you're not sure if the error is a SubmitError
+ */
+function extractFieldErrors(error) {
+    if (!error)
+        return [];
+    // If it's already a SubmitError
+    if (error.fieldErrors && Array.isArray(error.fieldErrors)) {
+        return error.fieldErrors;
+    }
+    // If it has a validationResponse
+    if (error.validationResponse?.errors && Array.isArray(error.validationResponse.errors)) {
+        return error.validationResponse.errors;
+    }
+    // Try to extract from response data
+    if (error.response?.errors && Array.isArray(error.response.errors)) {
+        return error.response.errors;
+    }
+    return [];
+}
+
+/**
+ * Formshive Submit Library
+ *
+ * A JavaScript library for submitting forms to Formshive with retry logic,
+ * file support, and flexible HTTP client options.
+ */
+// Export main functionality
+// Set up global object for browser usage
+if (typeof window !== 'undefined') {
+    window.FormshiveSubmit = {
+        submitForm,
+        submitFormSimple,
+        FormSubmitter,
+        validateFormData,
+        RetryPresets,
+        ERROR_CODES,
+        formatFileSize,
+        createLogger,
+        // Field validation utilities
+        isFieldValidationError,
+        getFieldErrors,
+        createFieldErrorHelpers,
+    };
+}
+// Default export for convenience
+var main = {
+    submitForm,
+    submitFormSimple,
+    FormSubmitter,
+    validateFormData,
+    RetryPresets,
+    ERROR_CODES,
+    formatFileSize,
+    createLogger,
+    // Field validation utilities
+    isFieldValidationError,
+    getFieldErrors,
+    createFieldErrorHelpers,
+};
+
+exports.ConsoleLogger = ConsoleLogger;
+exports.DEFAULT_FILE_CONFIG = DEFAULT_FILE_CONFIG;
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.DEFAULT_RETRY_CONFIG = DEFAULT_RETRY_CONFIG;
+exports.ERROR_CODES = ERROR_CODES;
+exports.FormSubmitter = FormSubmitter;
+exports.NoOpLogger = NoOpLogger;
+exports.RetryManager = RetryManager;
+exports.RetryPresets = RetryPresets;
+exports.buildSubmissionUrl = buildSubmissionUrl;
+exports.createFieldErrorHelpers = createFieldErrorHelpers;
+exports.createFieldErrorMap = createFieldErrorMap;
+exports.createHttpClient = createHttpClient;
+exports.createLogger = createLogger;
+exports.createProgressTracker = createProgressTracker;
+exports.createRetryableFunction = createRetryableFunction;
+exports.createSubmitError = createSubmitError;
+exports.createTimeoutPromise = createTimeoutPromise;
+exports.debounce = debounce;
+exports.deepClone = deepClone;
+exports.default = main;
+exports.ensureProtocol = ensureProtocol;
+exports.extractFieldErrors = extractFieldErrors;
+exports.extractFiles = extractFiles;
+exports.formatDuration = formatDuration;
+exports.formatFieldErrors = formatFieldErrors;
+exports.formatFieldErrorsWithCodes = formatFieldErrorsWithCodes;
+exports.formatFileSize = formatFileSize;
+exports.generateRequestId = generateRequestId;
+exports.getEnhancedFileInfo = getEnhancedFileInfo;
+exports.getEnvironmentInfo = getEnvironmentInfo;
+exports.getErrorFieldNames = getErrorFieldNames;
+exports.getErrorMessage = getErrorMessage;
+exports.getErrorsByCode = getErrorsByCode;
+exports.getFieldError = getFieldError;
+exports.getFieldErrors = getFieldErrors;
+exports.getFirstFieldError = getFirstFieldError;
+exports.getMimeTypeFromExtension = getMimeTypeFromExtension;
+exports.getNestedProperty = getNestedProperty;
+exports.getRetryDelayInfo = getRetryDelayInfo;
+exports.getValidationErrorSummary = getValidationErrorSummary;
+exports.getValidationResponse = getValidationResponse;
+exports.groupErrorsByCode = groupErrorsByCode;
+exports.hasErrorCode = hasErrorCode;
+exports.hasFieldError = hasFieldError;
+exports.hasFieldErrorCode = hasFieldErrorCode;
+exports.isBrowser = isBrowser;
+exports.isFetchAvailable = isFetchAvailable;
+exports.isFieldValidationError = isFieldValidationError;
+exports.isFormDataAvailable = isFormDataAvailable;
+exports.isRetryableError = isRetryableError;
+exports.isValidUrl = isValidUrl;
+exports.mergeObjects = mergeObjects;
+exports.objectToQueryString = objectToQueryString;
+exports.parseErrorMessage = parseErrorMessage;
+exports.processFormData = processFormData;
+exports.sanitizeForLogging = sanitizeForLogging;
+exports.simpleRetry = simpleRetry;
+exports.submitForm = submitForm;
+exports.submitFormSimple = submitFormSimple;
+exports.submitFormWithCallbacks = submitFormWithCallbacks;
+exports.throttle = throttle;
+exports.validateFile = validateFile;
+exports.validateFiles = validateFiles;
+exports.validateFormData = validateFormData;
+exports.withRetry = withRetry;
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=formshive-submit.cjs.map