@uploadista/client-browser 0.0.3 → 0.0.6

package/dist/index.d.ts

@@ -1,8 +1,583 @@
+import * as _uploadista_client_core0 from "@uploadista/client-core";
+import { ConnectionPoolConfig, FileReaderService, FlowResult, HttpClient, SliceResult, UploadResult, UploadistaClientOptions as UploadistaClientOptions$1 } from "@uploadista/client-core";
+import * as _uploadista_core0 from "@uploadista/core";
+import { FlowEvent } from "@uploadista/core/flow";
+import { UploadEvent, UploadFile } from "@uploadista/core/types";
 export * from "@uploadista/client-core";
-export { createUploadistaClient, type UploadistaClientOptions } from "./client";
-export * from "./framework-utils";
-export { createHttpClient } from "./http-client";
-export type { FileReader } from "./services/file-reader";
-export { createBrowserFileReaderService } from "./services/file-reader";
-export * from "./types";
+
+//#region src/types/upload-input.d.ts
+
+/**
+ * Browser-specific upload input types that can be used with the Uploadista client.
+ *
+ * In the browser environment, files can be provided as either:
+ * - `File` objects from file input elements or drag-and-drop
+ * - `Blob` objects created programmatically or from other sources
+ *
+ * Both types use the browser's File API and can be chunked for upload.
+ *
+ * @example
+ * ```typescript
+ * // From file input
+ * const fileInput = document.querySelector<HTMLInputElement>('input[type="file"]');
+ * const file: BrowserUploadInput = fileInput.files[0];
+ *
+ * // From drag and drop
+ * element.addEventListener('drop', (e) => {
+ *   const file: BrowserUploadInput = e.dataTransfer.files[0];
+ * });
+ *
+ * // From Blob
+ * const blob: BrowserUploadInput = new Blob(['content'], { type: 'text/plain' });
+ * ```
+ */
+type BrowserUploadInput = Blob | File;
+//#endregion
+//#region src/client/create-uploadista-client.d.ts
+/**
+ * Configuration options for creating a browser-specific Uploadista client.
+ *
+ * This interface extends the core client options but omits browser-specific
+ * services that are automatically provided by the browser environment.
+ * These services include WebSocket factory, AbortController, ID generation,
+ * storage, logging, platform detection, fingerprinting, HTTP client, file reader,
+ * and checksum calculation.
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaClient } from '@uploadista/client-browser';
+ *
+ * const client = createUploadistaClient({
+ *   endpoint: 'https://api.uploadista.com/upload',
+ *   connectionPooling: {
+ *     maxConnectionsPerHost: 6,
+ *     enableHttp2: true
+ *   }
+ * });
+ * ```
+ */
+interface UploadistaClientOptions extends Omit<UploadistaClientOptions$1<BrowserUploadInput>, "webSocketFactory" | "abortControllerFactory" | "generateId" | "clientStorage" | "logger" | "platformService" | "fingerprintService" | "httpClient" | "fileReader" | "checksumService"> {
+  /**
+   * Connection pooling configuration for the HTTP client.
+   *
+   * Controls how the browser manages HTTP connections for optimal performance.
+   * The browser's native fetch API with keep-alive headers is used under the hood.
+   *
+   * @default
+   * ```typescript
+   * {
+   *   maxConnectionsPerHost: 6,
+   *   connectionTimeout: 30000,
+   *   keepAliveTimeout: 60000,
+   *   enableHttp2: true,
+   *   retryOnConnectionError: true
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * connectionPooling: {
+   *   maxConnectionsPerHost: 10,
+   *   enableHttp2: true,
+   *   keepAliveTimeout: 120000
+   * }
+   * ```
+   */
+  connectionPooling?: ConnectionPoolConfig;
+}
+/**
+ * Creates a browser-optimized Uploadista client for file uploads and flow processing.
+ *
+ * This factory function automatically configures all browser-specific services including:
+ * - Fetch-based HTTP client with connection pooling
+ * - Native WebSocket support for real-time progress
+ * - localStorage for upload state persistence
+ * - Web Crypto API for checksums and fingerprints
+ * - File API for reading and chunking files
+ * - Browser platform detection and capabilities
+ *
+ * The created client can handle File and Blob objects from file inputs, drag-and-drop,
+ * or programmatically created content. It supports resumable uploads, progress tracking,
+ * and flow-based file processing.
+ *
+ * @param options - Configuration options for the browser client
+ * @returns A fully configured Uploadista client ready for browser use
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaClient } from '@uploadista/client-browser';
+ *
+ * // Basic usage
+ * const client = createUploadistaClient({
+ *   endpoint: 'https://api.uploadista.com/upload'
+ * });
+ *
+ * // With custom configuration
+ * const client = createUploadistaClient({
+ *   endpoint: 'https://api.uploadista.com/upload',
+ *   connectionPooling: {
+ *     maxConnectionsPerHost: 6,
+ *     enableHttp2: true,
+ *     keepAliveTimeout: 60000
+ *   },
+ *   chunkSize: 5 * 1024 * 1024, // 5MB chunks
+ *   retryDelays: [1000, 3000, 5000],
+ *   allowedMetaFields: ['userId', 'projectId']
+ * });
+ *
+ * // Upload a file
+ * const fileInput = document.querySelector('input[type="file"]');
+ * const file = fileInput.files[0];
+ *
+ * const upload = await client.upload(file, {
+ *   onProgress: (event) => {
+ *     console.log(`Progress: ${event.progress}%`);
+ *   }
+ * });
+ *
+ * console.log('Upload complete:', upload.id);
+ * ```
+ *
+ * @see {@link UploadistaClientOptions} for available configuration options
+ * @see {@link BrowserUploadInput} for supported file input types
+ */
+declare function createUploadistaClient(options: UploadistaClientOptions): {
+  upload: (file: BrowserUploadInput, {
+    uploadLengthDeferred,
+    uploadSize,
+    onProgress,
+    onChunkComplete,
+    onSuccess,
+    onShouldRetry,
+    onError
+  }?: _uploadista_client_core0.UploadistaUploadOptions) => Promise<{
+    abort: () => void;
+  }>;
+  uploadWithFlow: (file: BrowserUploadInput, flowConfig: _uploadista_client_core0.FlowUploadConfig, {
+    onProgress,
+    onChunkComplete,
+    onSuccess,
+    onShouldRetry,
+    onJobStart,
+    onError
+  }?: Omit<_uploadista_client_core0.UploadistaUploadOptions, "uploadLengthDeferred" | "uploadSize" | "metadata">) => Promise<{
+    abort: () => void;
+    jobId: string;
+  }>;
+  abort: (params: Parameters<({
+    uploadId,
+    uploadIdStorageKey,
+    retryTimeout,
+    shouldTerminate,
+    abortController,
+    uploadistaApi,
+    platformService,
+    retryDelays,
+    clientStorage
+  }: {
+    uploadId: string;
+    uploadIdStorageKey: string | undefined;
+    retryTimeout: _uploadista_client_core0.Timeout | null;
+    shouldTerminate: boolean;
+    abortController: _uploadista_client_core0.AbortControllerLike;
+    uploadistaApi: _uploadista_client_core0.UploadistaApi;
+    platformService: _uploadista_client_core0.PlatformService;
+    retryDelays?: number[];
+    clientStorage: _uploadista_client_core0.ClientStorage;
+  }) => Promise<void>>[0]) => Promise<void>;
+  getFlow: (flowId: string) => Promise<{
+    status: number;
+    flow: _uploadista_core0.FlowData;
+  }>;
+  runFlow: ({
+    flowId,
+    inputs,
+    storageId: flowStorageId
+  }: {
+    flowId: string;
+    inputs: Record<string, unknown>;
+    storageId?: string;
+  }) => Promise<{
+    status: number;
+    job: _uploadista_core0.FlowJob;
+  }>;
+  continueFlow: ({
+    jobId,
+    nodeId,
+    newData,
+    contentType
+  }: {
+    jobId: string;
+    nodeId: string;
+    newData: unknown;
+    contentType?: "application/json" | "application/octet-stream";
+  }) => Promise<_uploadista_core0.FlowJob>;
+  getJobStatus: (jobId: string) => Promise<_uploadista_core0.FlowJob>;
+  openUploadWebSocket: (uploadId: string) => Promise<_uploadista_client_core0.WebSocketLike>;
+  openFlowWebSocket: (jobId: string) => Promise<_uploadista_client_core0.WebSocketLike>;
+  openWebSocket: (id: string) => Promise<_uploadista_client_core0.WebSocketLike>;
+  closeWebSocket: (id: string) => void;
+  closeAllWebSockets: () => void;
+  sendPing: (jobId: string) => boolean;
+  isWebSocketConnected: (id: string) => boolean;
+  getWebSocketConnectionCount: () => number;
+  getWebSocketConnectionCountByType: () => {
+    upload: number;
+    flow: number;
+    total: number;
+  };
+  getNetworkMetrics: () => _uploadista_client_core0.NetworkMetrics;
+  getNetworkCondition: () => _uploadista_client_core0.NetworkCondition;
+  getChunkingInsights: () => _uploadista_client_core0.PerformanceInsights;
+  exportMetrics: () => {
+    session: Partial<_uploadista_client_core0.UploadSessionMetrics>;
+    chunks: _uploadista_client_core0.ChunkMetrics[];
+    insights: _uploadista_client_core0.PerformanceInsights;
+  };
+  getConnectionMetrics: () => _uploadista_client_core0.ConnectionMetrics;
+  getDetailedConnectionMetrics: () => _uploadista_client_core0.DetailedConnectionMetrics;
+  warmupConnections: (urls: string[]) => Promise<void>;
+  getConnectionPoolingInsights: () => Promise<{
+    isOptimized: boolean;
+    reuseRate: number;
+    recommendedMinChunkSize: number;
+    connectionOverhead: number;
+  }>;
+  resetMetrics: () => Promise<void>;
+  validateConfiguration: (options: UploadistaClientOptions$1<BrowserUploadInput>) => {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+  };
+  validateConfigurationAsync: (options: UploadistaClientOptions$1<BrowserUploadInput>) => Promise<{
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    capabilities: _uploadista_core0.DataStoreCapabilities;
+  }>;
+  getCapabilities: () => Promise<_uploadista_core0.DataStoreCapabilities>;
+};
+//#endregion
+//#region src/framework-utils.d.ts
+/**
+ * Base upload state that framework wrappers should implement
+ */
+interface BaseUploadState {
+  status: "idle" | "uploading" | "success" | "error" | "aborted";
+  progress: number;
+  bytesUploaded: number;
+  totalBytes: number;
+  error?: Error;
+  result?: UploadResult<UploadFile>;
+}
+/**
+ * Base flow upload state
+ */
+interface BaseFlowUploadState extends BaseUploadState {
+  jobId?: string;
+  flowStatus?: "pending" | "processing" | "completed" | "failed";
+  flowResult?: FlowResult<unknown>;
+}
+/**
+ * Progress callback signature
+ */
+type ProgressCallback = (uploadId: string, bytesUploaded: number, totalBytes: number) => void;
+/**
+ * Complete callback signature
+ */
+type CompleteCallback = (uploadId: string, result: UploadResult) => void;
+/**
+ * Error callback signature
+ */
+type ErrorCallback = (uploadId: string, error: Error) => void;
+/**
+ * Abort callback signature
+ */
+type AbortCallback = (uploadId: string) => void;
+/**
+ * Event handler signature for framework wrappers
+ */
+type EventHandler<T = unknown> = (event: T) => void;
+/**
+ * WebSocket event handler signature
+ */
+type WebSocketEventHandler = (event: UploadEvent | FlowEvent) => void;
+/**
+ * Framework state updater function signature
+ * @template T - The state type
+ */
+type StateUpdater<T> = (updater: (prevState: T) => T) => void;
+/**
+ * Cleanup function returned by setup functions
+ */
+type CleanupFunction = () => void;
+/**
+ * Upload item for multi-upload tracking
+ */
+interface UploadItem {
+  id: string;
+  file: File;
+  status: BaseUploadState["status"];
+  progress: number;
+  bytesUploaded: number;
+  totalBytes: number;
+  error?: Error;
+  result?: UploadResult;
+}
+/**
+ * Multi-upload aggregate statistics
+ */
+interface MultiUploadStats {
+  totalFiles: number;
+  completedFiles: number;
+  failedFiles: number;
+  totalBytes: number;
+  uploadedBytes: number;
+  totalProgress: number;
+  allComplete: boolean;
+  hasErrors: boolean;
+}
+/**
+ * Drag and drop state
+ */
+interface DragDropState {
+  isDragging: boolean;
+  isOver: boolean;
+  files: File[];
+}
+/**
+ * File validation result
+ */
+interface FileValidationResult {
+  valid: boolean;
+  error?: string;
+}
+/**
+ * File validation function signature
+ */
+type FileValidator = (file: File) => FileValidationResult;
+/**
+ * Utility: Calculate aggregate upload statistics
+ */
+declare function calculateMultiUploadStats(uploads: UploadItem[]): MultiUploadStats;
+/**
+ * Utility: Format file size for display
+ */
+declare function formatFileSize(bytes: number): string;
+/**
+ * Utility: Format progress percentage
+ */
+declare function formatProgress(progress: number): string;
+/**
+ * Utility: Get file extension
+ */
+declare function getFileExtension(filename: string): string;
+/**
+ * Utility: Check if file is an image
+ */
+declare function isImageFile(file: File): boolean;
+/**
+ * Utility: Check if file is a video
+ */
+declare function isVideoFile(file: File): boolean;
+/**
+ * Utility: Create file size validator
+ */
+declare function createFileSizeValidator(maxSizeBytes: number): FileValidator;
+/**
+ * Utility: Create file type validator
+ */
+declare function createFileTypeValidator(allowedTypes: string[]): FileValidator;
+/**
+ * Utility: Compose multiple validators
+ */
+declare function composeValidators(...validators: FileValidator[]): FileValidator;
+/**
+ * Utility: Generate unique upload ID
+ */
+declare function generateUploadId(): string;
+/**
+ * Utility: Create delay promise for retry logic
+ */
+declare function delay(ms: number): Promise<void>;
+/**
+ * Utility: Calculate exponential backoff delay
+ */
+declare function calculateBackoff(attempt: number, baseDelay?: number, maxDelay?: number): number;
+/**
+ * Utility: Create retry wrapper for upload function
+ */
+declare function createRetryWrapper<T>(fn: () => Promise<T>, maxAttempts?: number, shouldRetry?: (error: unknown) => boolean): () => Promise<T>;
+/**
+ * Type guard: Check if error is network-related (should retry)
+ */
+declare function isNetworkError(error: unknown): boolean;
+/**
+ * Type guard: Check if error is abort-related (should not retry)
+ */
+declare function isAbortError(error: unknown): boolean;
+/**
+ * Format upload speed in human-readable format
+ */
+declare function formatSpeed(bytesPerSecond: number): string;
+/**
+ * Format duration in human-readable format
+ */
+declare function formatDuration(milliseconds: number): string;
+/**
+ * Validate file type against accepted types
+ */
+declare function validateFileType(file: File, accept: string[]): boolean;
+/**
+ * Check if a file is an audio file
+ */
+declare function isAudioFile(file: File): boolean;
+/**
+ * Check if a file is a document
+ */
+declare function isDocumentFile(file: File): boolean;
+/**
+ * Create a preview URL for a file (if supported)
+ */
+declare function createFilePreview(file: File): string | null;
+/**
+ * Clean up a preview URL created with createFilePreview
+ */
+declare function revokeFilePreview(previewUrl: string): void;
+/**
+ * Calculate progress percentage
+ */
+declare function calculateProgress(current: number, total: number): number;
+//#endregion
+//#region src/http-client.d.ts
+/**
+ * Creates a browser-optimized HTTP client using the Fetch API.
+ *
+ * This factory function returns an HttpClient implementation that uses the browser's
+ * native fetch() API with connection keep-alive headers for optimal performance.
+ * The client automatically manages connection pooling, tracks metrics, and provides
+ * connection health monitoring.
+ *
+ * @param config - Optional connection pooling configuration
+ * @returns A configured HTTP client ready for making requests
+ *
+ * @example
+ * ```typescript
+ * import { createHttpClient } from '@uploadista/client-browser';
+ *
+ * // Basic usage with defaults
+ * const client = createHttpClient();
+ *
+ * // With custom configuration
+ * const client = createHttpClient({
+ *   maxConnectionsPerHost: 10,
+ *   connectionTimeout: 60000,
+ *   keepAliveTimeout: 120000,
+ *   enableHttp2: true,
+ *   retryOnConnectionError: true
+ * });
+ *
+ * // Make a request
+ * const response = await client.request('https://api.example.com/data', {
+ *   method: 'POST',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   body: JSON.stringify({ key: 'value' })
+ * });
+ *
+ * // Check connection health
+ * const metrics = client.getDetailedMetrics();
+ * console.log('Connection health:', metrics.health.status);
+ * ```
+ *
+ * @see {@link BrowserHttpClient} for implementation details
+ */
+declare function createHttpClient(config?: ConnectionPoolConfig): HttpClient;
+//#endregion
+//#region src/services/file-reader.d.ts
+/**
+ * Browser-specific file reader interface for opening and reading file data.
+ *
+ * Provides methods to open File/Blob objects and create FileSource instances
+ * that support chunked reading for upload operations.
+ */
+type FileReader = {
+  /**
+   * Opens a file and prepares it for chunked reading.
+   *
+   * @param input - The File or Blob to open
+   * @param chunkSize - Size of chunks to read (in bytes)
+   * @returns Promise resolving to a FileSource for reading the file
+   */
+  openFile: (input: BrowserUploadInput, chunkSize: number) => Promise<FileSource>;
+};
+/**
+ * Represents an opened file that can be read in chunks.
+ *
+ * This interface provides the core functionality for reading file data
+ * in a streaming fashion, which is essential for uploading large files
+ * without loading them entirely into memory.
+ */
+type FileSource = {
+  /** The original input File or Blob */
+  input: BrowserUploadInput;
+  /** Total size of the file in bytes, or null if unknown */
+  size: number | null;
+  /**
+   * Reads a slice of data from the file.
+   *
+   * @param start - Starting byte offset
+   * @param end - Ending byte offset (exclusive)
+   * @returns Promise resolving to the slice result with data and metadata
+   */
+  slice: (start: number, end: number) => Promise<SliceResult>;
+  /**
+   * Closes the file and releases any resources.
+   *
+   * For browser File/Blob objects, this is typically a no-op as there are
+   * no resources to release, but is included for interface compatibility.
+   */
+  close: () => void;
+};
+/**
+ * Creates a browser-specific file reader service for the Uploadista client.
+ *
+ * This service provides the ability to open and read File/Blob objects from
+ * the browser's File API. It converts browser-native file objects into a
+ * format that can be chunked and uploaded efficiently.
+ *
+ * The service currently supports:
+ * - File objects from `<input type="file">` elements
+ * - File objects from drag-and-drop events
+ * - Blob objects created programmatically
+ *
+ * Future support may include:
+ * - ReadableStream for streaming data
+ *
+ * @returns A FileReaderService configured for browser environments
+ *
+ * @example
+ * ```typescript
+ * import { createBrowserFileReaderService } from '@uploadista/client-browser';
+ *
+ * const fileReader = createBrowserFileReaderService();
+ *
+ * // Open a file from input element
+ * const input = document.querySelector('input[type="file"]');
+ * const file = input.files[0];
+ * const source = await fileReader.openFile(file, 5 * 1024 * 1024); // 5MB chunks
+ *
+ * console.log('File name:', source.name);
+ * console.log('File size:', source.size);
+ * console.log('File type:', source.type);
+ *
+ * // Read first chunk
+ * const chunk = await source.slice(0, 5 * 1024 * 1024);
+ * console.log('Read', chunk.size, 'bytes');
+ * ```
+ *
+ * @throws {Error} When the input is not a File or Blob
+ */
+declare function createBrowserFileReaderService(): FileReaderService<BrowserUploadInput>;
+//#endregion
+export { AbortCallback, BaseFlowUploadState, BaseUploadState, BrowserUploadInput, CleanupFunction, CompleteCallback, DragDropState, ErrorCallback, EventHandler, type FileReader, FileValidationResult, FileValidator, MultiUploadStats, ProgressCallback, StateUpdater, UploadItem, type UploadistaClientOptions, WebSocketEventHandler, calculateBackoff, calculateMultiUploadStats, calculateProgress, composeValidators, createBrowserFileReaderService, createFilePreview, createFileSizeValidator, createFileTypeValidator, createHttpClient, createRetryWrapper, createUploadistaClient, delay, formatDuration, formatFileSize, formatProgress, formatSpeed, generateUploadId, getFileExtension, isAbortError, isAudioFile, isDocumentFile, isImageFile, isNetworkError, isVideoFile, revokeFilePreview, validateFileType };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,yBAAyB,CAAC;AACxC,OAAO,EAAE,sBAAsB,EAAE,KAAK,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAChF,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,YAAY,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AACxE,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types/upload-input.ts","../src/client/create-uploadista-client.ts","../src/framework-utils.ts","../src/http-client.ts","../src/services/file-reader.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.js

@@ -1,7 +1,2 @@
-// Re-export everything from client-core
-export * from "@uploadista/client-core";
-export { createUploadistaClient } from "./client";
-export * from "./framework-utils";
-export { createHttpClient } from "./http-client";
-export { createBrowserFileReaderService } from "./services/file-reader";
-export * from "./types";
+import{createClientStorage as e,createLogger as t,createUploadistaClient as n}from"@uploadista/client-core";export*from"@uploadista/client-core";function r(e){return new i(e)}var i=class{config;metrics;connectionTimes=[];requestCount=0;connectionCount=0;errorCount=0;timeoutCount=0;retryCount=0;startTime=Date.now();http2Info;constructor(e={}){this.config={maxConnectionsPerHost:e.maxConnectionsPerHost??6,connectionTimeout:e.connectionTimeout??3e4,keepAliveTimeout:e.keepAliveTimeout??6e4,enableHttp2:e.enableHttp2??!0,retryOnConnectionError:e.retryOnConnectionError??!0},this.metrics={activeConnections:0,totalConnections:0,reuseRate:0,averageConnectionTime:0},this.http2Info=this.detectHttp2Support()}detectHttp2Support(){let e=`serviceWorker`in navigator&&`fetch`in window,t=`ReadableStream`in window&&`WritableStream`in window&&`TransformStream`in window;return{supported:e,detected:!1,version:t?`h2`:`h1.1`,multiplexingActive:t&&this.config.enableHttp2}}async request(e,t={}){this.requestCount++;let n={method:t.method||`GET`,headers:{Connection:`keep-alive`,"Keep-Alive":`timeout=${this.config.keepAliveTimeout/1e3}`,...t.headers},body:t.body,credentials:t.credentials||`include`,signal:t.signal};if(t.timeout){let r=new AbortController,i=setTimeout(()=>r.abort(),t.timeout);t.signal&&t.signal.addEventListener(`abort`,()=>r.abort()),n.signal=r.signal;try{let t=await this.makeRequest(e,n);return clearTimeout(i),t}catch(e){throw clearTimeout(i),e}}return this.makeRequest(e,n)}async makeRequest(e,t){let n=Date.now();try{let r=await fetch(e,t),i=Date.now()-n;return this.recordConnectionMetrics(i),{status:r.status,statusText:r.statusText,headers:r.headers,ok:r.ok,json:()=>r.json(),text:()=>r.text(),arrayBuffer:()=>r.arrayBuffer()}}catch(e){throw this.connectionCount++,e}}recordConnectionMetrics(e){this.connectionTimes.push(e),this.connectionCount++,this.connectionTimes.length>100&&this.connectionTimes.shift(),this.metrics.totalConnections=this.connectionCount,this.metrics.averageConnectionTime=this.connectionTimes.reduce((e,t)=>e+t,0)/this.connectionTimes.length;let t=this.connectionTimes.filter(e=>e<100).length;this.metrics.reuseRate=t/this.connectionTimes.length}getMetrics(){return{...this.metrics}}getDetailedMetrics(){let e=this.calculateConnectionHealth(),t=(Date.now()-this.startTime)/1e3,n=t>0?this.requestCount/t:0,r=this.requestCount>0?this.errorCount/this.requestCount:0,i=this.connectionTimes.filter(e=>e<100).length,a=this.connectionTimes.length-i;return{...this.metrics,health:e,requestsPerSecond:n,errorRate:r,timeouts:this.timeoutCount,retries:this.retryCount,fastConnections:i,slowConnections:a,http2Info:this.http2Info}}calculateConnectionHealth(){let e=[],t=[],n=100;this.metrics.reuseRate<.3?(e.push(`Low connection reuse rate`),t.push(`Check if keep-alive headers are working`),n-=30):this.metrics.reuseRate<.7&&(e.push(`Moderate connection reuse rate`),t.push(`Consider adjusting keep-alive timeout`),n-=15);let r=this.requestCount>0?this.errorCount/this.requestCount:0;r>.1?(e.push(`High error rate`),t.push(`Check network stability and server configuration`),n-=25):r>.05&&(e.push(`Moderate error rate`),t.push(`Monitor network conditions`),n-=10),this.metrics.averageConnectionTime>1e3?(e.push(`Slow connection establishment`),t.push(`Check network latency and DNS resolution`),n-=20):this.metrics.averageConnectionTime>500&&(e.push(`Moderate connection latency`),t.push(`Consider connection warming`),n-=10);let i;return i=n>=80?`healthy`:n>=60?`degraded`:`poor`,{status:i,score:Math.max(0,n),issues:e,recommendations:t}}async warmupConnections(e){if(e.length===0)return;console.log(`Warming up connections to ${e.length} hosts...`);let t=e.map(async e=>{try{await this.request(e,{method:`HEAD`,timeout:5e3})}catch(t){console.warn(`Connection warmup failed for ${e}:`,t)}});await Promise.allSettled(t),console.log(`Connection warmup completed`)}reset(){this.connectionTimes=[],this.requestCount=0,this.connectionCount=0,this.errorCount=0,this.timeoutCount=0,this.retryCount=0,this.startTime=Date.now(),this.metrics={activeConnections:0,totalConnections:0,reuseRate:0,averageConnectionTime:0},this.http2Info=this.detectHttp2Support()}async close(){console.log(`Gracefully shutting down HTTP client...`),await new Promise(e=>setTimeout(e,100));let e=this.getDetailedMetrics();console.log(`Final connection metrics:`,{totalRequests:this.requestCount,connectionReuse:`${Math.round(e.reuseRate*100)}%`,averageConnectionTime:`${Math.round(e.averageConnectionTime)}ms`,health:e.health.status}),this.reset(),console.log(`HTTP client shutdown complete`)}},a=class{native;constructor(){this.native=new AbortController}get signal(){return this.native.signal}abort(e){this.native.abort(e)}};const o=()=>({create:()=>new a});async function s(e){try{let t=await e.arrayBuffer(),n=await crypto.subtle.digest(`SHA-256`,t);return Array.from(new Uint8Array(n)).map(e=>e.toString(16).padStart(2,`0`)).join(``)}catch(e){throw Error(`Failed to compute file checksum: ${e instanceof Error?e.message:`Unknown error`}`)}}function c(){return{computeChecksum:async e=>s(new Blob([e]))}}function l(e){return{input:e,size:e.size,slice:async(t,n)=>{let r=e.slice(t,n),i=r.size,a=n>=e.size;return{value:new Uint8Array(await r.arrayBuffer()),size:i,done:a}},close:()=>{}}}function u(){return{openFile:async(e,t)=>{if(e instanceof Blob){let t=l(e);return{input:t.input,size:t.size,slice:t.slice,close:t.close,name:t.input instanceof File?t.input.name:null,type:t.input instanceof File?t.input.type:null,lastModified:t.input instanceof File?t.input.lastModified:null}}throw Error(`source object may only be an instance of File, Blob in this environment`)}}}function d(){return{computeFingerprint:async(e,t)=>s(e)}}function f(){return{generate:()=>crypto.randomUUID()}}function p(){return{setTimeout:(e,t)=>globalThis.setTimeout(e,t),clearTimeout:e=>{globalThis.clearTimeout(e)},isBrowser:()=>typeof window<`u`,isOnline:()=>typeof navigator<`u`?navigator.onLine:!0,isFileLike:e=>e instanceof File,getFileName:e=>{if(e instanceof File)return e.name},getFileType:e=>{if(e instanceof File)return e.type},getFileSize:e=>{if(e instanceof File)return e.size},getFileLastModified:e=>{if(e instanceof File)return e.lastModified}}}function m(){let e=e=>{let t={};for(let n in localStorage)if(n.startsWith(e)){let e=localStorage.getItem(n);e&&(t[n]=e)}return t};return{async getItem(e){return localStorage.getItem(e)},async setItem(e,t){localStorage.setItem(e,t)},async removeItem(e){localStorage.removeItem(e)},async findAll(){return e(``)},async find(t){return e(t)}}}var h=class{CONNECTING=0;OPEN=1;CLOSING=2;CLOSED=3;readyState;onopen=null;onclose=null;onerror=null;onmessage=null;native;constructor(e){this.native=new WebSocket(e),this.readyState=this.native.readyState,this.native.onopen=()=>{this.readyState=this.native.readyState,this.onopen?.()},this.native.onclose=e=>{this.readyState=this.native.readyState;let t=e;this.onclose?.({code:t.code,reason:t.reason})},this.native.onerror=e=>{this.onerror?.({message:`WebSocket error`})},this.native.onmessage=e=>{let t=e;this.onmessage?.({data:t.data})}}send(e){this.native.send(e)}close(e,t){this.native.close(e,t)}};const g=()=>({create:e=>new h(e)});function _(e={}){let{connectionPooling:t,useLocalStorage:n=!0}=e,i=m(),a=f(),s=r(t),l=u(),h=g(),_=o(),v=c(),y=d();return{platform:p(),storage:i,idGeneration:a,httpClient:s,fileReader:l,websocket:h,abortController:_,checksumService:v,fingerprintService:y}}function v(r){let i=_({connectionPooling:r.connectionPooling});return n({...r,webSocketFactory:i.websocket,abortControllerFactory:i.abortController,platformService:i.platform,httpClient:i.httpClient,fileReader:i.fileReader,generateId:i.idGeneration,fingerprintService:i.fingerprintService,checksumService:i.checksumService,logger:t(!1,()=>{}),clientStorage:e(i.storage)})}function y(e){let t=e.length,n=e.filter(e=>e.status===`success`).length,r=e.filter(e=>e.status===`error`).length,i=e.reduce((e,t)=>e+t.totalBytes,0),a=e.reduce((e,t)=>e+t.bytesUploaded,0);return{totalFiles:t,completedFiles:n,failedFiles:r,totalBytes:i,uploadedBytes:a,totalProgress:i>0?a/i*100:0,allComplete:e.every(e=>e.status===`success`),hasErrors:e.some(e=>e.status===`error`)}}function b(e){if(e===0)return`0 Bytes`;let t=1024,n=[`Bytes`,`KB`,`MB`,`GB`,`TB`],r=Math.floor(Math.log(e)/Math.log(t));return`${Number.parseFloat((e/t**r).toFixed(2))} ${n[r]}`}function x(e){return`${Math.round(e)}%`}function S(e){let t=e.lastIndexOf(`.`);return t===-1?``:e.slice(t+1).toLowerCase()}function C(e){return e.type.startsWith(`image/`)}function w(e){return e.type.startsWith(`video/`)}function T(e){return t=>t.size>e?{valid:!1,error:`File size exceeds maximum of ${b(e)}`}:{valid:!0}}function E(e){return t=>{let n=t.type.toLowerCase(),r=S(t.name);return e.some(e=>{if(e.startsWith(`.`))return e.slice(1)===r;if(e.includes(`*`)){let t=e.replace(`*`,``);return n.startsWith(t)}return n===e})?{valid:!0}:{valid:!1,error:`File type not allowed. Allowed types: ${e.join(`, `)}`}}}function D(...e){return t=>{for(let n of e){let e=n(t);if(!e.valid)return e}return{valid:!0}}}function O(){return`upload-${Date.now()}-${Math.random().toString(36).substr(2,9)}`}function k(e){return new Promise(t=>setTimeout(t,e))}function A(e,t=1e3,n=3e4){return Math.min(t*2**e,n)+Math.random()*1e3}function j(e,t=3,n=()=>!0){return async()=>{let r;for(let i=0;i<t;i++)try{return await e()}catch(e){if(r=e,i<t-1&&n(e)){await k(A(i));continue}break}throw r}}function M(e){return e instanceof Error?e.message.includes(`network`)||e.message.includes(`timeout`)||e.message.includes(`connection`)||e.message.includes(`ECONNREFUSED`)||e.message.includes(`ETIMEDOUT`):!1}function N(e){return e instanceof Error?e.name===`AbortError`||e.message.includes(`abort`):!1}function P(e){if(e===0)return`0 B/s`;let t=1024,n=[`B/s`,`KB/s`,`MB/s`,`GB/s`],r=Math.floor(Math.log(e)/Math.log(t));return`${parseFloat((e/t**r).toFixed(1))} ${n[r]}`}function F(e){if(e<1e3)return`${Math.round(e)}ms`;if(e<6e4)return`${Math.round(e/1e3)}s`;if(e<36e5){let t=Math.floor(e/6e4),n=Math.round(e%6e4/1e3);return n>0?`${t}m ${n}s`:`${t}m`}let t=Math.floor(e/36e5),n=Math.round(e%36e5/6e4);return n>0?`${t}h ${n}m`:`${t}h`}function I(e,t){return!t||t.length===0?!0:t.some(t=>{if(t.startsWith(`.`))return e.name.toLowerCase().endsWith(t.toLowerCase());if(t.endsWith(`/*`)){let n=t.slice(0,-2);return e.type.startsWith(n)}return e.type===t})}function L(e){return e.type.startsWith(`audio/`)}function R(e){return[`application/pdf`,`application/msword`,`application/vnd.openxmlformats-officedocument.wordprocessingml.document`,`application/vnd.ms-excel`,`application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`,`application/vnd.ms-powerpoint`,`application/vnd.openxmlformats-officedocument.presentationml.presentation`,`text/plain`,`text/csv`,`application/rtf`].includes(e.type)}function z(e){return C(e)||w(e)||L(e)?URL.createObjectURL(e):null}function B(e){URL.revokeObjectURL(e)}function V(e,t){return t===0?0:Math.min(100,Math.max(0,Math.round(e/t*100)))}export{A as calculateBackoff,y as calculateMultiUploadStats,V as calculateProgress,D as composeValidators,u as createBrowserFileReaderService,z as createFilePreview,T as createFileSizeValidator,E as createFileTypeValidator,r as createHttpClient,j as createRetryWrapper,v as createUploadistaClient,k as delay,F as formatDuration,b as formatFileSize,x as formatProgress,P as formatSpeed,O as generateUploadId,S as getFileExtension,N as isAbortError,L as isAudioFile,R as isDocumentFile,C as isImageFile,M as isNetworkError,w as isVideoFile,B as revokeFilePreview,I as validateFileType};
+//# sourceMappingURL=index.js.map