@gofranz/formshive-submit 1.0.0

package/dist/formshive-submit.js

@@ -0,0 +1,1720 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FormshiveSubmit = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * 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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=formshive-submit.js.map