@uploadista/react 0.0.20-beta.1 → 0.0.20-beta.3

package/dist/{use-uploadista-client-m9nF-irM.d.mts → use-uploadista-client-DHbLSpIb.d.mts}

@@ -1,209 +1,7 @@
+import { FlowUploadState, FlowUploadStatus, InputExecutionState, UploadMetrics, UploadState, UploadStatus } from "@uploadista/client-core";
 import { UploadFile } from "@uploadista/core/types";
-import { FlowUploadState, FlowUploadState as FlowUploadState$1, FlowUploadStatus, InputExecutionState, UploadMetrics, UploadState, UploadStatus } from "@uploadista/client-core";
 import { BrowserUploadInput, FlowUploadOptions, UploadistaClientOptions, createUploadistaClient } from "@uploadista/client-browser";
 
-//#region src/hooks/use-flow.d.ts
-
-/**
- * Input metadata discovered from the flow
- */
-interface FlowInputMetadata {
-  /** Input node ID */
-  nodeId: string;
-  /** Human-readable node name */
-  nodeName: string;
-  /** Node description explaining what input is needed */
-  nodeDescription: string;
-  /** Input type ID from inputTypeRegistry - describes how clients interact with this node */
-  inputTypeId?: string;
-  /** Whether this input is required */
-  required: boolean;
-}
-/**
- * Return value from the useFlow hook with upload control methods and state.
- *
- * @property state - Complete flow upload state with progress and outputs
- * @property inputMetadata - Metadata about discovered input nodes (null until discovered)
- * @property inputStates - Per-input execution state for multi-input flows
- * @property inputs - Current input values set via setInput()
- * @property setInput - Set an input value for a specific node (for progressive provision)
- * @property execute - Execute the flow with current inputs (auto-detects types)
- * @property upload - Convenience method for single-file upload (same as execute with one file input)
- * @property abort - Cancel the current upload and flow execution
- * @property pause - Pause the current upload
- * @property reset - Reset state to idle (clears all data)
- * @property isUploading - True when upload or processing is active
- * @property isUploadingFile - True only during file upload phase
- * @property isProcessing - True only during flow processing phase
- * @property isDiscoveringInputs - True while discovering flow inputs
- */
-interface UseFlowReturn {
-  /**
-   * Current upload state
-   */
-  state: FlowUploadState$1;
-  /**
-   * Discovered input nodes metadata (null until discovery completes)
-   */
-  inputMetadata: FlowInputMetadata[] | null;
-  /**
-   * Per-input execution state for multi-input flows
-   */
-  inputStates: ReadonlyMap<string, InputExecutionState>;
-  /**
-   * Current inputs set via setInput()
-   */
-  inputs: Record<string, unknown>;
-  /**
-   * Set an input value for a specific node.
-   * For progressive input provision before calling execute().
-   *
-   * @param nodeId - The input node ID
-   * @param value - The input value (File, URL string, or structured data)
-   */
-  setInput: (nodeId: string, value: unknown) => void;
-  /**
-   * Execute the flow with current inputs.
-   * Automatically detects input types and routes appropriately.
-   * For single input, uses standard upload path.
-   * For multiple inputs, requires multiInputUploadFn.
-   */
-  execute: () => Promise<void>;
-  /**
-   * Upload a single file through the flow (convenience method).
-   * Equivalent to setInput(firstNodeId, file) + execute().
-   *
-   * @param file - File or Blob to upload
-   */
-  upload: (file: File | Blob) => Promise<void>;
-  /**
-   * Abort the current upload
-   */
-  abort: () => void;
-  /**
-   * Pause the current upload
-   */
-  pause: () => void;
-  /**
-   * Reset the upload state and clear all inputs
-   */
-  reset: () => void;
-  /**
-   * Whether an upload or flow execution is in progress (uploading OR processing)
-   */
-  isUploading: boolean;
-  /**
-   * Whether the file is currently being uploaded (chunks being sent)
-   */
-  isUploadingFile: boolean;
-  /**
-   * Whether the flow is currently processing (after upload completes)
-   */
-  isProcessing: boolean;
-  /**
-   * Whether the hook is discovering flow inputs
-   */
-  isDiscoveringInputs: boolean;
-}
-/**
- * React hook for executing flows with single or multiple inputs.
- * Automatically discovers input nodes and detects input types (File, URL, structured data).
- * Supports progressive input provision via setInput() and execute().
- *
- * This is the unified flow hook that replaces useFlowUpload for advanced use cases.
- * It provides:
- * - Auto-discovery of flow input nodes
- * - Automatic input type detection (file → upload, string → URL, object → data)
- * - Progressive input provision via setInput()
- * - Multi-input support with parallel coordination
- * - Per-input state tracking
- *
- * Must be used within FlowManagerProvider (which must be within UploadistaProvider).
- * Flow events are automatically routed by the provider to the appropriate manager.
- *
- * @param options - Flow upload configuration including flow ID and event handlers
- * @returns Flow upload state and control methods
- *
- * @example
- * ```tsx
- * // Single file upload (simple case)
- * function SingleFileUploader() {
- *   const flow = useFlow({
- *     flowConfig: {
- *       flowId: "image-optimization",
- *       storageId: "s3-images",
- *     },
- *     onSuccess: (outputs) => {
- *       console.log("Flow outputs:", outputs);
- *     },
- *   });
- *
- *   return (
- *     <div>
- *       <input
- *         type="file"
- *         onChange={(e) => {
- *           const file = e.target.files?.[0];
- *           if (file) flow.upload(file);
- *         }}
- *       />
- *       {flow.isUploading && <div>Progress: {flow.state.progress}%</div>}
- *     </div>
- *   );
- * }
- *
- * // Multi-input with progressive provision
- * function MultiInputFlow() {
- *   const flow = useFlow({
- *     flowConfig: {
- *       flowId: "multi-source-processing",
- *       storageId: "default",
- *     },
- *   });
- *
- *   return (
- *     <div>
- *       {flow.inputMetadata?.map((input) => (
- *         <div key={input.nodeId}>
- *           <label>{input.nodeId}</label>
- *           {input.nodeType === "streaming-input-v1" ? (
- *             <input
- *               type="file"
- *               onChange={(e) => {
- *                 const file = e.target.files?.[0];
- *                 if (file) flow.setInput(input.nodeId, file);
- *               }}
- *             />
- *           ) : (
- *             <input
- *               type="url"
- *               onChange={(e) => flow.setInput(input.nodeId, e.target.value)}
- *             />
- *           )}
- *         </div>
- *       ))}
- *       <button onClick={flow.execute} disabled={flow.isUploading}>
- *         Execute Flow
- *       </button>
- *
- *       {flow.isUploading && (
- *         <div>
- *           {Array.from(flow.inputStates.values()).map((inputState) => (
- *             <div key={inputState.nodeId}>
- *               {inputState.nodeId}: {inputState.status} ({inputState.progress}%)
- *             </div>
- *           ))}
- *         </div>
- *       )}
- *     </div>
- *   );
- * }
- * ```
- *
- * @see {@link useFlowUpload} for a simpler file-only upload hook
- */
-declare function useFlow(options: FlowUploadOptions): UseFlowReturn;
-//#endregion
 //#region src/hooks/use-drag-drop.d.ts
 interface DragDropOptions {
   /**
@@ -354,26 +152,77 @@ interface UseDragDropReturn {
  */
 declare function useDragDrop(options?: DragDropOptions): UseDragDropReturn;
 //#endregion
-//#region src/hooks/use-flow-upload.d.ts
+//#region src/hooks/use-flow.d.ts
+/**
+ * Input metadata discovered from the flow
+ */
+interface FlowInputMetadata {
+  /** Input node ID */
+  nodeId: string;
+  /** Human-readable node name */
+  nodeName: string;
+  /** Node description explaining what input is needed */
+  nodeDescription: string;
+  /** Input type ID from inputTypeRegistry - describes how clients interact with this node */
+  inputTypeId?: string;
+  /** Whether this input is required */
+  required: boolean;
+}
 /**
- * Return value from the useFlowUpload hook with upload control methods and state.
+ * Return value from the useFlow hook with upload control methods and state.
  *
  * @property state - Complete flow upload state with progress and outputs
- * @property upload - Function to initiate file upload through the flow
+ * @property inputMetadata - Metadata about discovered input nodes (null until discovered)
+ * @property inputStates - Per-input execution state for multi-input flows
+ * @property inputs - Current input values set via setInput()
+ * @property setInput - Set an input value for a specific node (for progressive provision)
+ * @property execute - Execute the flow with current inputs (auto-detects types)
+ * @property upload - Convenience method for single-file upload (same as execute with one file input)
  * @property abort - Cancel the current upload and flow execution
  * @property pause - Pause the current upload
  * @property reset - Reset state to idle (clears all data)
  * @property isUploading - True when upload or processing is active
  * @property isUploadingFile - True only during file upload phase
  * @property isProcessing - True only during flow processing phase
+ * @property isDiscoveringInputs - True while discovering flow inputs
  */
-interface UseFlowUploadReturn {
+interface UseFlowReturn {
   /**
    * Current upload state
    */
   state: FlowUploadState;
   /**
-   * Upload a file through the flow
+   * Discovered input nodes metadata (null until discovery completes)
+   */
+  inputMetadata: FlowInputMetadata[] | null;
+  /**
+   * Per-input execution state for multi-input flows
+   */
+  inputStates: ReadonlyMap<string, InputExecutionState>;
+  /**
+   * Current inputs set via setInput()
+   */
+  inputs: Record<string, unknown>;
+  /**
+   * Set an input value for a specific node.
+   * For progressive input provision before calling execute().
+   *
+   * @param nodeId - The input node ID
+   * @param value - The input value (File, URL string, or structured data)
+   */
+  setInput: (nodeId: string, value: unknown) => void;
+  /**
+   * Execute the flow with current inputs.
+   * Automatically detects input types and routes appropriately.
+   * For single input, uses standard upload path.
+   * For multiple inputs, requires multiInputUploadFn.
+   */
+  execute: () => Promise<void>;
+  /**
+   * Upload a single file through the flow (convenience method).
+   * Equivalent to setInput(firstNodeId, file) + execute().
+   *
+   * @param file - File or Blob to upload
    */
   upload: (file: File | Blob) => Promise<void>;
   /**
@@ -385,7 +234,7 @@ interface UseFlowUploadReturn {
    */
   pause: () => void;
   /**
-   * Reset the upload state
+   * Reset the upload state and clear all inputs
    */
   reset: () => void;
   /**
@@ -400,18 +249,23 @@ interface UseFlowUploadReturn {
    * Whether the flow is currently processing (after upload completes)
    */
   isProcessing: boolean;
+  /**
+   * Whether the hook is discovering flow inputs
+   */
+  isDiscoveringInputs: boolean;
 }
 /**
- * React hook for uploading files through a flow with automatic flow execution.
- * Handles both the file upload phase and the flow processing phase, providing
- * real-time progress updates and flow node execution tracking.
- *
- * This is a convenience wrapper around the generic useFlowExecution hook,
- * specialized for the common case of file uploads. For more flexible input types
- * (URLs, structured data), use useFlowExecution directly with an inputBuilder.
+ * React hook for executing flows with single or multiple inputs.
+ * Automatically discovers input nodes and detects input types (File, URL, structured data).
+ * Supports progressive input provision via setInput() and execute().
  *
- * The flow engine processes the uploaded file through a DAG of nodes, which can
- * perform operations like image optimization, storage saving, webhooks, etc.
+ * This is the unified flow hook that replaces useFlowUpload for advanced use cases.
+ * It provides:
+ * - Auto-discovery of flow input nodes
+ * - Automatic input type detection (file → upload, string → URL, object → data)
+ * - Progressive input provision via setInput()
+ * - Multi-input support with parallel coordination
+ * - Per-input state tracking
  *
  * Must be used within FlowManagerProvider (which must be within UploadistaProvider).
  * Flow events are automatically routed by the provider to the appropriate manager.
@@ -419,46 +273,17 @@ interface UseFlowUploadReturn {
  * @param options - Flow upload configuration including flow ID and event handlers
  * @returns Flow upload state and control methods
  *
- * @remarks
- * **Future refactoring**: This hook could be implemented as a thin wrapper around
- * useFlowExecution with a file-specific inputBuilder:
- * ```typescript
- * return useFlowExecution<File | Blob>({
- *   ...options,
- *   inputBuilder: async (file) => {
- *     const { inputNodes } = await client.findInputNode(options.flowConfig.flowId);
- *     return {
- *       [inputNodes[0].id]: {
- *         operation: "init",
- *         storageId: options.flowConfig.storageId,
- *         metadata: { originalName: file.name, mimeType: file.type, size: file.size }
- *       }
- *     };
- *   }
- * });
- * ```
- *
  * @example
  * ```tsx
- * // Basic flow upload with progress tracking
- * function ImageUploader() {
- *   const flowUpload = useFlowUpload({
+ * // Single file upload (simple case)
+ * function SingleFileUploader() {
+ *   const flow = useFlow({
  *     flowConfig: {
- *       flowId: "image-optimization-flow",
+ *       flowId: "image-optimization",
  *       storageId: "s3-images",
  *     },
  *     onSuccess: (outputs) => {
  *       console.log("Flow outputs:", outputs);
- *       // Access all outputs from the flow
- *       for (const output of outputs) {
- *         console.log(`${output.nodeId}:`, output.data);
- *       }
- *     },
- *     onFlowComplete: (outputs) => {
- *       console.log("All flow outputs:", outputs);
- *     },
- *     onError: (error) => {
- *       console.error("Upload or processing failed:", error);
  *     },
  *   });
  *
@@ -466,58 +291,67 @@ interface UseFlowUploadReturn {
  *     <div>
  *       <input
  *         type="file"
- *         accept="image/*"
  *         onChange={(e) => {
  *           const file = e.target.files?.[0];
- *           if (file) flowUpload.upload(file);
+ *           if (file) flow.upload(file);
  *         }}
  *       />
+ *       {flow.isUploading && <div>Progress: {flow.state.progress}%</div>}
+ *     </div>
+ *   );
+ * }
  *
- *       {flowUpload.isUploadingFile && (
- *         <div>Uploading... {flowUpload.state.progress}%</div>
- *       )}
+ * // Multi-input with progressive provision
+ * function MultiInputFlow() {
+ *   const flow = useFlow({
+ *     flowConfig: {
+ *       flowId: "multi-source-processing",
+ *       storageId: "default",
+ *     },
+ *   });
  *
- *       {flowUpload.isProcessing && (
- *         <div>
- *           Processing...
- *           {flowUpload.state.currentNodeName && (
- *             <span>Current step: {flowUpload.state.currentNodeName}</span>
+ *   return (
+ *     <div>
+ *       {flow.inputMetadata?.map((input) => (
+ *         <div key={input.nodeId}>
+ *           <label>{input.nodeId}</label>
+ *           {input.nodeType === "streaming-input-v1" ? (
+ *             <input
+ *               type="file"
+ *               onChange={(e) => {
+ *                 const file = e.target.files?.[0];
+ *                 if (file) flow.setInput(input.nodeId, file);
+ *               }}
+ *             />
+ *           ) : (
+ *             <input
+ *               type="url"
+ *               onChange={(e) => flow.setInput(input.nodeId, e.target.value)}
+ *             />
  *           )}
  *         </div>
- *       )}
+ *       ))}
+ *       <button onClick={flow.execute} disabled={flow.isUploading}>
+ *         Execute Flow
+ *       </button>
  *
- *       {flowUpload.state.status === "success" && (
+ *       {flow.isUploading && (
  *         <div>
- *           <p>Upload complete!</p>
- *           {flowUpload.state.flowOutputs && (
- *             <div>
- *               {flowUpload.state.flowOutputs.map((output) => (
- *                 <div key={output.nodeId}>{output.nodeId}: {JSON.stringify(output.data)}</div>
- *               ))}
+ *           {Array.from(flow.inputStates.values()).map((inputState) => (
+ *             <div key={inputState.nodeId}>
+ *               {inputState.nodeId}: {inputState.status} ({inputState.progress}%)
  *             </div>
- *           )}
- *         </div>
- *       )}
- *
- *       {flowUpload.state.status === "error" && (
- *         <div>
- *           <p>Error: {flowUpload.state.error?.message}</p>
- *           <button onClick={flowUpload.reset}>Try Again</button>
+ *           ))}
  *         </div>
  *       )}
- *
- *       {flowUpload.isUploading && (
- *         <button onClick={flowUpload.abort}>Cancel</button>
- *       )}
  *     </div>
  *   );
  * }
  * ```
  *
- * @see {@link useMultiFlowUpload} for uploading multiple files through a flow
- * @see {@link useUpload} for simple uploads without flow processing
+ * @see {@link useFlowUpload} for a simpler file-only upload hook
  */
-declare function useFlowUpload(options: FlowUploadOptions): UseFlowUploadReturn;
+declare function useFlow(options: FlowUploadOptions): UseFlowReturn;
 //#endregion
 //#region src/hooks/use-upload.d.ts
 interface UseUploadOptions {
@@ -911,5 +745,5 @@ interface UseUploadistaClientReturn {
  */
 declare function useUploadistaClient(options: UseUploadistaClientOptions): UseUploadistaClientReturn;
 //#endregion
-export { InputExecutionState as C, FlowInputMetadata as S, useFlow as T, useFlowUpload as _, MultiUploadState as a, UseDragDropReturn as b, useMultiUpload as c, UseUploadOptions as d, UseUploadReturn as f, UseFlowUploadReturn as g, FlowUploadStatus as h, MultiUploadOptions as i, UploadState as l, FlowUploadState as m, UseUploadistaClientReturn as n, UploadItem as o, useUpload as p, useUploadistaClient as r, UseMultiUploadReturn as s, UseUploadistaClientOptions as t, UploadStatus as u, DragDropOptions as v, UseFlowReturn as w, useDragDrop as x, DragDropState as y };
-//# sourceMappingURL=use-uploadista-client-m9nF-irM.d.mts.map
+export { useDragDrop as C, UseDragDropReturn as S, InputExecutionState as _, MultiUploadState as a, DragDropOptions as b, useMultiUpload as c, UseUploadOptions as d, UseUploadReturn as f, FlowUploadStatus as g, FlowUploadState as h, MultiUploadOptions as i, UploadState as l, FlowInputMetadata as m, UseUploadistaClientReturn as n, UploadItem as o, useUpload as p, useUploadistaClient as r, UseMultiUploadReturn as s, UseUploadistaClientOptions as t, UploadStatus as u, UseFlowReturn as v, DragDropState as x, useFlow as y };
+//# sourceMappingURL=use-uploadista-client-DHbLSpIb.d.mts.map

package/dist/use-uploadista-client-DHbLSpIb.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-uploadista-client-DHbLSpIb.d.mts","names":[],"sources":["../src/hooks/use-drag-drop.ts","../src/hooks/use-flow.ts","../src/hooks/use-upload.ts","../src/hooks/use-multi-upload.ts","../src/hooks/use-uploadista-client.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/use-uploadista-events-BwUD-2Ck.mjs

@@ -0,0 +1,2 @@
+import{o as e}from"./use-upload-BvvGROMR.mjs";import t,{useCallback as n,useEffect as r,useRef as i,useState as a}from"react";import{EventType as o}from"@uploadista/core/flow";import{UploadEventType as s}from"@uploadista/core/types";function c(e){if(!(`eventType`in e))return!1;let t=e;return t.eventType===o.JobStart||t.eventType===o.JobEnd||t.eventType===o.FlowStart||t.eventType===o.FlowEnd||t.eventType===o.FlowError||t.eventType===o.FlowPause||t.eventType===o.FlowCancel||t.eventType===o.NodeStart||t.eventType===o.NodeEnd||t.eventType===o.NodePause||t.eventType===o.NodeResume||t.eventType===o.NodeError||t.eventType===o.NodeStream||t.eventType===o.NodeResponse}function l(e){if(!(`type`in e))return!1;let t=e;return t.type===s.UPLOAD_STARTED||t.type===s.UPLOAD_PROGRESS||t.type===s.UPLOAD_COMPLETE||t.type===s.UPLOAD_FAILED||t.type===s.UPLOAD_VALIDATION_SUCCESS||t.type===s.UPLOAD_VALIDATION_FAILED||t.type===s.UPLOAD_VALIDATION_WARNING}function u(t){let{subscribeToEvents:n}=e();r(()=>n(e=>{if(c(e))switch(e.eventType){case o.JobStart:t.onJobStart?.(e);break;case o.JobEnd:t.onJobEnd?.(e);break;case o.FlowStart:t.onFlowStart?.(e);break;case o.FlowEnd:t.onFlowEnd?.(e);break;case o.FlowError:t.onFlowError?.(e);break;case o.FlowPause:t.onFlowPause?.(e);break;case o.FlowCancel:t.onFlowCancel?.(e);break;case o.NodeStart:t.onNodeStart?.(e);break;case o.NodeEnd:t.onNodeEnd?.(e);break;case o.NodePause:t.onNodePause?.(e);break;case o.NodeResume:t.onNodeResume?.(e);break;case o.NodeError:t.onNodeError?.(e);break}}),[n,t])}function d(t){let{subscribeToEvents:n}=e();r(()=>n(e=>{if(!l(e))return;let n=`flow`in e?e.flow:void 0;switch(e.type){case s.UPLOAD_STARTED:t.onUploadStarted?.({...e.data,flow:n});break;case s.UPLOAD_PROGRESS:t.onUploadProgress?.({...e.data,flow:n});break;case s.UPLOAD_COMPLETE:t.onUploadComplete?.({...e.data,flow:n});break;case s.UPLOAD_FAILED:t.onUploadFailed?.({...e.data,flow:n});break;case s.UPLOAD_VALIDATION_SUCCESS:t.onUploadValidationSuccess?.({...e.data,flow:n});break;case s.UPLOAD_VALIDATION_FAILED:t.onUploadValidationFailed?.({...e.data,flow:n});break;case s.UPLOAD_VALIDATION_WARNING:t.onUploadValidationWarning?.({...e.data,flow:n});break}}),[n,t])}const f={totalBytesUploaded:0,totalBytes:0,averageSpeed:0,currentSpeed:0,estimatedTimeRemaining:null,totalFiles:0,completedFiles:0,activeUploads:0,progress:0,peakSpeed:0,startTime:null,endTime:null,totalDuration:null,insights:{overallEfficiency:0,chunkingEffectiveness:0,networkStability:0,recommendations:[],optimalChunkSizeRange:{min:256*1024,max:2*1024*1024}},sessionMetrics:[],chunkMetrics:[]};function p(r={}){let{speedCalculationInterval:o=1e3,speedSampleSize:s=10,onMetricsUpdate:c,onFileStart:l,onFileProgress:u,onFileComplete:d}=r,p=e(),[m,h]=a(f),[g,_]=a([]),v=i([]),y=i(0),b=i(null),x=n((e,t)=>{let n={time:e,bytes:t};v.current.push(n),v.current.length>s&&(v.current=v.current.slice(-s));let r=0;if(v.current.length>=2){let e=v.current[v.current.length-1],t=v.current[v.current.length-2];if(e&&t){let n=(e.time-t.time)/1e3,i=e.bytes-t.bytes;r=n>0?i/n:0}}let i=0;if(v.current.length>=2){let e=v.current[0],t=v.current[v.current.length-1];if(e&&t){let n=(t.time-e.time)/1e3,r=t.bytes-e.bytes;i=n>0?r/n:0}}return{currentSpeed:r,averageSpeed:i}},[s]),S=n(()=>{let e=Date.now(),t=g.reduce((e,t)=>e+t.size,0),n=g.reduce((e,t)=>e+t.bytesUploaded,0),r=g.filter(e=>e.isComplete).length,i=g.filter(e=>!e.isComplete&&e.bytesUploaded>0).length,{currentSpeed:a,averageSpeed:o}=x(e,n),s=t>0?Math.round(n/t*100):0,l=null;a>0&&(l=(t-n)/a*1e3);let u=g.filter(e=>e.startTime>0),d=u.length>0?Math.min(...u.map(e=>e.startTime)):null,f=g.filter(e=>e.endTime!==null),_=f.length>0&&r===g.length?Math.max(...f.map(e=>e.endTime).filter(e=>e!==null)):null,v=d&&_?_-d:null,y={totalBytesUploaded:n,totalBytes:t,averageSpeed:o,currentSpeed:a,estimatedTimeRemaining:l,totalFiles:g.length,completedFiles:r,activeUploads:i,progress:s,peakSpeed:Math.max(m.peakSpeed,a),startTime:d,endTime:_,totalDuration:v,insights:p.client.getChunkingInsights(),sessionMetrics:[p.client.exportMetrics().session],chunkMetrics:p.client.exportMetrics().chunks};h(y),c?.(y)},[g,m.peakSpeed,x,c,p.client]),C=n(()=>(b.current&&clearInterval(b.current),b.current=setInterval(()=>{g.some(e=>!e.isComplete&&e.bytesUploaded>0)&&S()},o),()=>{b.current&&=(clearInterval(b.current),null)}),[o,S,g]),w=n((e,t,n)=>{let r={id:e,filename:t,size:n,bytesUploaded:0,progress:0,speed:0,startTime:Date.now(),endTime:null,duration:null,isComplete:!1};_(t=>t.find(t=>t.id===e)?t.map(t=>t.id===e?r:t):[...t,r]),l?.(r),g.filter(e=>!e.isComplete).length===0&&C()},[g,l,C]),T=n((e,t)=>{let n=Date.now();_(r=>r.map(r=>{if(r.id!==e)return r;let i=(n-r.startTime)/1e3,a=i>0?t/i:0,o=r.size>0?Math.round(t/r.size*100):0,s={...r,bytesUploaded:t,progress:o,speed:a};return u?.(s),s})),setTimeout(S,0)},[u,S]),E=n(e=>{let t=Date.now();_(n=>n.map(n=>{if(n.id!==e)return n;let r=t-n.startTime,i=r>0?n.size/r*1e3:0,a={...n,bytesUploaded:n.size,progress:100,speed:i,endTime:t,duration:r,isComplete:!0};return d?.(a),a})),setTimeout(S,0)},[d,S]),D=n(e=>{_(t=>t.filter(t=>t.id!==e)),setTimeout(S,0)},[S]),O=n(()=>{b.current&&=(clearInterval(b.current),null),h(f),_([]),v.current=[],y.current=0},[]),k=n(e=>g.find(t=>t.id===e),[g]),A=n(()=>({overall:m,files:g,exportTime:Date.now()}),[m,g]);return t.useEffect(()=>()=>{b.current&&clearInterval(b.current)},[]),{metrics:m,fileMetrics:g,startFileUpload:w,updateFileProgress:T,completeFileUpload:E,removeFile:D,reset:O,getFileMetrics:k,exportMetrics:A}}function m(t){let{subscribeToEvents:n}=e();r(()=>n(t),[n,t])}export{c as a,u as i,p as n,l as o,d as r,m as t};
+//# sourceMappingURL=use-uploadista-events-BwUD-2Ck.mjs.map

package/dist/use-uploadista-events-BwUD-2Ck.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-uploadista-events-BwUD-2Ck.mjs","names":["initialMetrics: UploadMetrics","estimatedTimeRemaining: number | null","newMetrics: UploadMetrics","fileMetric: FileUploadMetrics"],"sources":["../src/hooks/event-utils.ts","../src/hooks/use-flow-events.ts","../src/hooks/use-upload-events.ts","../src/hooks/use-upload-metrics.ts","../src/hooks/use-uploadista-events.ts"],"sourcesContent":["import type { UploadistaEvent } from \"@uploadista/client-browser\";\nimport { EventType, type FlowEvent } from \"@uploadista/core/flow\";\nimport { UploadEventType, type UploadEvent } from \"@uploadista/core/types\";\n\n/**\n * Type guard to check if an event is a flow event\n */\nexport function isFlowEvent(event: UploadistaEvent): event is FlowEvent {\n  if (!(\"eventType\" in event)) return false;\n  const e = event as { eventType: unknown };\n  return (\n    e.eventType === EventType.JobStart ||\n    e.eventType === EventType.JobEnd ||\n    e.eventType === EventType.FlowStart ||\n    e.eventType === EventType.FlowEnd ||\n    e.eventType === EventType.FlowError ||\n    e.eventType === EventType.FlowPause ||\n    e.eventType === EventType.FlowCancel ||\n    e.eventType === EventType.NodeStart ||\n    e.eventType === EventType.NodeEnd ||\n    e.eventType === EventType.NodePause ||\n    e.eventType === EventType.NodeResume ||\n    e.eventType === EventType.NodeError ||\n    e.eventType === EventType.NodeStream ||\n    e.eventType === EventType.NodeResponse\n  );\n}\n\n/**\n * Type guard to check if an event is an upload event\n */\nexport function isUploadEvent(event: UploadistaEvent): event is UploadEvent {\n  if (!(\"type\" in event)) return false;\n  const e = event as { type: unknown };\n  return (\n    e.type === UploadEventType.UPLOAD_STARTED ||\n    e.type === UploadEventType.UPLOAD_PROGRESS ||\n    e.type === UploadEventType.UPLOAD_COMPLETE ||\n    e.type === UploadEventType.UPLOAD_FAILED ||\n    e.type === UploadEventType.UPLOAD_VALIDATION_SUCCESS ||\n    e.type === UploadEventType.UPLOAD_VALIDATION_FAILED ||\n    e.type === UploadEventType.UPLOAD_VALIDATION_WARNING\n  );\n}\n","import type {\n  FlowEventFlowCancel,\n  FlowEventFlowEnd,\n  FlowEventFlowError,\n  FlowEventFlowPause,\n  FlowEventFlowStart,\n  FlowEventJobEnd,\n  FlowEventJobStart,\n  FlowEventNodeEnd,\n  FlowEventNodeError,\n  FlowEventNodePause,\n  FlowEventNodeResume,\n  FlowEventNodeStart,\n} from \"@uploadista/core/flow\";\nimport { EventType } from \"@uploadista/core/flow\";\nimport { useEffect } from \"react\";\nimport { useUploadistaContext } from \"../components/uploadista-provider\";\nimport { isFlowEvent } from \"./event-utils\";\n\n/**\n * Options for handling flow execution events.\n *\n * All callbacks are optional - only provide handlers for events you care about.\n */\nexport interface UseFlowEventsOptions {\n  /** Called when a job starts execution */\n  onJobStart?: (event: FlowEventJobStart) => void;\n  /** Called when a job completes (success or failure) */\n  onJobEnd?: (event: FlowEventJobEnd) => void;\n  /** Called when a flow begins execution */\n  onFlowStart?: (event: FlowEventFlowStart) => void;\n  /** Called when a flow completes successfully */\n  onFlowEnd?: (event: FlowEventFlowEnd) => void;\n  /** Called when a flow encounters an error */\n  onFlowError?: (event: FlowEventFlowError) => void;\n  /** Called when a flow is paused by user request */\n  onFlowPause?: (event: FlowEventFlowPause) => void;\n  /** Called when a flow is cancelled by user request */\n  onFlowCancel?: (event: FlowEventFlowCancel) => void;\n  /** Called when a node starts processing */\n  onNodeStart?: (event: FlowEventNodeStart) => void;\n  /** Called when a node completes successfully */\n  onNodeEnd?: (event: FlowEventNodeEnd) => void;\n  /** Called when a node pauses (waiting for additional data) */\n  onNodePause?: (event: FlowEventNodePause) => void;\n  /** Called when a paused node resumes execution */\n  onNodeResume?: (event: FlowEventNodeResume) => void;\n  /** Called when a node encounters an error */\n  onNodeError?: (event: FlowEventNodeError) => void;\n}\n\n/**\n * Structured hook for handling flow execution events with type-safe callbacks.\n *\n * This hook provides a clean API for listening to specific flow events without\n * needing to manually filter events or use type guards.\n *\n * Must be used within UploadistaProvider.\n *\n * @param options - Object with optional callbacks for each flow event type\n *\n * @example\n * ```tsx\n * import { useFlowEvents } from '@uploadista/react';\n *\n * function FlowMonitor() {\n *   useFlowEvents({\n *     onFlowStart: (event) => {\n *       console.log('Flow started:', event.flowId);\n *     },\n *     onNodeStart: (event) => {\n *       console.log('Node started:', event.nodeName);\n *     },\n *     onNodeEnd: (event) => {\n *       console.log('Node completed:', event.nodeName, event.result);\n *     },\n *     onFlowEnd: (event) => {\n *       console.log('Flow completed with outputs:', event.outputs);\n *     },\n *     onFlowError: (event) => {\n *       console.error('Flow failed:', event.error);\n *     },\n *   });\n *\n *   return <div>Monitoring flow execution...</div>;\n * }\n * ```\n */\nexport function useFlowEvents(options: UseFlowEventsOptions): void {\n  const { subscribeToEvents } = useUploadistaContext();\n\n  useEffect(() => {\n    const unsubscribe = subscribeToEvents((event) => {\n      // Only handle flow events\n      if (!isFlowEvent(event)) return;\n\n      // Route to appropriate callback based on event type\n      switch (event.eventType) {\n        case EventType.JobStart:\n          options.onJobStart?.(event);\n          break;\n        case EventType.JobEnd:\n          options.onJobEnd?.(event);\n          break;\n        case EventType.FlowStart:\n          options.onFlowStart?.(event);\n          break;\n        case EventType.FlowEnd:\n          options.onFlowEnd?.(event);\n          break;\n        case EventType.FlowError:\n          options.onFlowError?.(event);\n          break;\n        case EventType.FlowPause:\n          options.onFlowPause?.(event);\n          break;\n        case EventType.FlowCancel:\n          options.onFlowCancel?.(event);\n          break;\n        case EventType.NodeStart:\n          options.onNodeStart?.(event);\n          break;\n        case EventType.NodeEnd:\n          options.onNodeEnd?.(event);\n          break;\n        case EventType.NodePause:\n          options.onNodePause?.(event);\n          break;\n        case EventType.NodeResume:\n          options.onNodeResume?.(event);\n          break;\n        case EventType.NodeError:\n          options.onNodeError?.(event);\n          break;\n      }\n    });\n\n    return unsubscribe;\n  }, [subscribeToEvents, options]);\n}\n","import { UploadEventType, type UploadEvent } from \"@uploadista/core/types\";\nimport { useEffect } from \"react\";\nimport { useUploadistaContext } from \"../components/uploadista-provider\";\nimport { isUploadEvent } from \"./event-utils\";\n\n/**\n * Upload progress event data\n */\nexport interface UploadProgressEventData {\n  id: string;\n  progress: number;\n  total: number;\n  flow?: {\n    flowId: string;\n    nodeId: string;\n    jobId: string;\n  };\n}\n\n/**\n * Upload started/complete event data (contains full UploadFile)\n */\nexport interface UploadFileEventData {\n  // This will contain the full UploadFile schema\n  [key: string]: unknown;\n  flow?: {\n    flowId: string;\n    nodeId: string;\n    jobId: string;\n  };\n}\n\n/**\n * Upload failed event data\n */\nexport interface UploadFailedEventData {\n  id: string;\n  error: string;\n  flow?: {\n    flowId: string;\n    nodeId: string;\n    jobId: string;\n  };\n}\n\n/**\n * Upload validation success event data\n */\nexport interface UploadValidationSuccessEventData {\n  id: string;\n  validationType: \"checksum\" | \"mimetype\";\n  algorithm?: string;\n  flow?: {\n    flowId: string;\n    nodeId: string;\n    jobId: string;\n  };\n}\n\n/**\n * Upload validation failed event data\n */\nexport interface UploadValidationFailedEventData {\n  id: string;\n  reason: string;\n  expected: string;\n  actual: string;\n  flow?: {\n    flowId: string;\n    nodeId: string;\n    jobId: string;\n  };\n}\n\n/**\n * Upload validation warning event data\n */\nexport interface UploadValidationWarningEventData {\n  id: string;\n  message: string;\n  flow?: {\n    flowId: string;\n    nodeId: string;\n    jobId: string;\n  };\n}\n\n/**\n * Options for handling upload events.\n *\n * All callbacks are optional - only provide handlers for events you care about.\n */\nexport interface UseUploadEventsOptions {\n  /** Called when an upload starts */\n  onUploadStarted?: (data: UploadFileEventData) => void;\n  /** Called with upload progress updates */\n  onUploadProgress?: (data: UploadProgressEventData) => void;\n  /** Called when an upload completes successfully */\n  onUploadComplete?: (data: UploadFileEventData) => void;\n  /** Called when an upload fails */\n  onUploadFailed?: (data: UploadFailedEventData) => void;\n  /** Called when upload validation succeeds */\n  onUploadValidationSuccess?: (data: UploadValidationSuccessEventData) => void;\n  /** Called when upload validation fails */\n  onUploadValidationFailed?: (data: UploadValidationFailedEventData) => void;\n  /** Called when upload validation produces a warning */\n  onUploadValidationWarning?: (data: UploadValidationWarningEventData) => void;\n}\n\n/**\n * Structured hook for handling upload events with type-safe callbacks.\n *\n * This hook provides a clean API for listening to specific upload events without\n * needing to manually filter events or use type guards.\n *\n * Must be used within UploadistaProvider.\n *\n * @param options - Object with optional callbacks for each upload event type\n *\n * @example\n * ```tsx\n * import { useUploadEvents } from '@uploadista/react';\n *\n * function UploadMonitor() {\n *   useUploadEvents({\n *     onUploadStarted: (data) => {\n *       console.log('Upload started:', data.id);\n *     },\n *     onUploadProgress: (data) => {\n *       const percent = (data.progress / data.total) * 100;\n *       console.log(`Upload progress: ${percent}%`);\n *     },\n *     onUploadComplete: (data) => {\n *       console.log('Upload completed:', data);\n *     },\n *     onUploadFailed: (data) => {\n *       console.error('Upload failed:', data.error);\n *     },\n *   });\n *\n *   return <div>Monitoring uploads...</div>;\n * }\n * ```\n */\nexport function useUploadEvents(options: UseUploadEventsOptions): void {\n  const { subscribeToEvents } = useUploadistaContext();\n\n  useEffect(() => {\n    const unsubscribe = subscribeToEvents((event) => {\n      // Only handle upload events\n      if (!isUploadEvent(event)) return;\n\n      // Route to appropriate callback based on event type\n      // Note: flow context is at the top level of the event, not inside data\n      const flowContext = \"flow\" in event ? event.flow : undefined;\n\n      switch (event.type) {\n        case UploadEventType.UPLOAD_STARTED:\n          options.onUploadStarted?.({\n            ...(event.data as unknown as Omit<UploadFileEventData, \"flow\">),\n            flow: flowContext,\n          });\n          break;\n        case UploadEventType.UPLOAD_PROGRESS:\n          options.onUploadProgress?.({\n            ...(event.data as unknown as Omit<\n              UploadProgressEventData,\n              \"flow\"\n            >),\n            flow: flowContext,\n          });\n          break;\n        case UploadEventType.UPLOAD_COMPLETE:\n          options.onUploadComplete?.({\n            ...(event.data as unknown as Omit<UploadFileEventData, \"flow\">),\n            flow: flowContext,\n          });\n          break;\n        case UploadEventType.UPLOAD_FAILED:\n          options.onUploadFailed?.({\n            ...(event.data as unknown as Omit<UploadFailedEventData, \"flow\">),\n            flow: flowContext,\n          });\n          break;\n        case UploadEventType.UPLOAD_VALIDATION_SUCCESS:\n          options.onUploadValidationSuccess?.({\n            ...(event.data as unknown as Omit<\n              UploadValidationSuccessEventData,\n              \"flow\"\n            >),\n            flow: flowContext,\n          });\n          break;\n        case UploadEventType.UPLOAD_VALIDATION_FAILED:\n          options.onUploadValidationFailed?.({\n            ...(event.data as unknown as Omit<\n              UploadValidationFailedEventData,\n              \"flow\"\n            >),\n            flow: flowContext,\n          });\n          break;\n        case UploadEventType.UPLOAD_VALIDATION_WARNING:\n          options.onUploadValidationWarning?.({\n            ...(event.data as unknown as Omit<\n              UploadValidationWarningEventData,\n              \"flow\"\n            >),\n            flow: flowContext,\n          });\n          break;\n      }\n    });\n\n    return unsubscribe;\n  }, [subscribeToEvents, options]);\n}\n","import type {\n  ChunkMetrics,\n  PerformanceInsights,\n  UploadSessionMetrics,\n} from \"@uploadista/client-core\";\nimport React, { useCallback, useRef, useState } from \"react\";\nimport { useUploadistaContext } from \"../components/uploadista-provider\";\n\nexport type Timeout = ReturnType<typeof setInterval>;\n\nexport interface UploadMetrics {\n  /**\n   * Total bytes uploaded across all files\n   */\n  totalBytesUploaded: number;\n\n  /**\n   * Total bytes to upload across all files\n   */\n  totalBytes: number;\n\n  /**\n   * Overall upload speed in bytes per second\n   */\n  averageSpeed: number;\n\n  /**\n   * Current upload speed in bytes per second\n   */\n  currentSpeed: number;\n\n  /**\n   * Estimated time remaining in milliseconds\n   */\n  estimatedTimeRemaining: number | null;\n\n  /**\n   * Total number of files being tracked\n   */\n  totalFiles: number;\n\n  /**\n   * Number of files completed\n   */\n  completedFiles: number;\n\n  /**\n   * Number of files currently uploading\n   */\n  activeUploads: number;\n\n  /**\n   * Overall progress as percentage (0-100)\n   */\n  progress: number;\n\n  /**\n   * Peak upload speed achieved\n   */\n  peakSpeed: number;\n\n  /**\n   * Start time of the first upload\n   */\n  startTime: number | null;\n\n  /**\n   * End time of the last completed upload\n   */\n  endTime: number | null;\n\n  /**\n   * Total duration of all uploads\n   */\n  totalDuration: number | null;\n\n  /**\n   * Detailed performance insights from the upload client\n   */\n  insights: PerformanceInsights;\n\n  /**\n   * Session metrics for completed uploads\n   */\n  sessionMetrics: Partial<UploadSessionMetrics>[];\n\n  /**\n   * Detailed chunk metrics from recent uploads\n   */\n  chunkMetrics: ChunkMetrics[];\n}\n\nexport interface FileUploadMetrics {\n  id: string;\n  filename: string;\n  size: number;\n  bytesUploaded: number;\n  progress: number;\n  speed: number;\n  startTime: number;\n  endTime: number | null;\n  duration: number | null;\n  isComplete: boolean;\n}\n\nexport interface UseUploadMetricsOptions {\n  /**\n   * Interval for calculating current speed (in milliseconds)\n   */\n  speedCalculationInterval?: number;\n\n  /**\n   * Number of speed samples to keep for average calculation\n   */\n  speedSampleSize?: number;\n\n  /**\n   * Called when metrics are updated\n   */\n  onMetricsUpdate?: (metrics: UploadMetrics) => void;\n\n  /**\n   * Called when a file upload starts\n   */\n  onFileStart?: (fileMetrics: FileUploadMetrics) => void;\n\n  /**\n   * Called when a file upload progresses\n   */\n  onFileProgress?: (fileMetrics: FileUploadMetrics) => void;\n\n  /**\n   * Called when a file upload completes\n   */\n  onFileComplete?: (fileMetrics: FileUploadMetrics) => void;\n}\n\nexport interface UseUploadMetricsReturn {\n  /**\n   * Current overall metrics\n   */\n  metrics: UploadMetrics;\n\n  /**\n   * Individual file metrics\n   */\n  fileMetrics: FileUploadMetrics[];\n\n  /**\n   * Start tracking a new file upload\n   */\n  startFileUpload: (id: string, filename: string, size: number) => void;\n\n  /**\n   * Update progress for a file upload\n   */\n  updateFileProgress: (id: string, bytesUploaded: number) => void;\n\n  /**\n   * Mark a file upload as complete\n   */\n  completeFileUpload: (id: string) => void;\n\n  /**\n   * Remove a file from tracking\n   */\n  removeFile: (id: string) => void;\n\n  /**\n   * Reset all metrics\n   */\n  reset: () => void;\n\n  /**\n   * Get metrics for a specific file\n   */\n  getFileMetrics: (id: string) => FileUploadMetrics | undefined;\n\n  /**\n   * Export metrics as JSON\n   */\n  exportMetrics: () => {\n    overall: UploadMetrics;\n    files: FileUploadMetrics[];\n    exportTime: number;\n  };\n}\n\nconst initialMetrics: UploadMetrics = {\n  totalBytesUploaded: 0,\n  totalBytes: 0,\n  averageSpeed: 0,\n  currentSpeed: 0,\n  estimatedTimeRemaining: null,\n  totalFiles: 0,\n  completedFiles: 0,\n  activeUploads: 0,\n  progress: 0,\n  peakSpeed: 0,\n  startTime: null,\n  endTime: null,\n  totalDuration: null,\n  insights: {\n    overallEfficiency: 0,\n    chunkingEffectiveness: 0,\n    networkStability: 0,\n    recommendations: [],\n    optimalChunkSizeRange: { min: 256 * 1024, max: 2 * 1024 * 1024 },\n  },\n  sessionMetrics: [],\n  chunkMetrics: [],\n};\n\n/**\n * React hook for tracking detailed upload metrics and performance statistics.\n * Provides comprehensive monitoring of upload progress, speed, and timing data.\n *\n * @param options - Configuration and event handlers\n * @returns Upload metrics state and control methods\n *\n * @example\n * ```tsx\n * const uploadMetrics = useUploadMetrics({\n *   speedCalculationInterval: 1000, // Update speed every second\n *   speedSampleSize: 10, // Keep last 10 speed samples for average\n *   onMetricsUpdate: (metrics) => {\n *     console.log(`Overall progress: ${metrics.progress}%`);\n *     console.log(`Speed: ${(metrics.currentSpeed / 1024).toFixed(1)} KB/s`);\n *     console.log(`ETA: ${metrics.estimatedTimeRemaining}ms`);\n *   },\n *   onFileComplete: (fileMetrics) => {\n *     console.log(`${fileMetrics.filename} completed in ${fileMetrics.duration}ms`);\n *   },\n * });\n *\n * // Start tracking a file\n * const handleFileStart = (file: File) => {\n *   uploadMetrics.startFileUpload(file.name, file.name, file.size);\n * };\n *\n * // Update progress during upload\n * const handleProgress = (fileId: string, bytesUploaded: number) => {\n *   uploadMetrics.updateFileProgress(fileId, bytesUploaded);\n * };\n *\n * // Display metrics\n * return (\n *   <div>\n *     <div>Overall Progress: {uploadMetrics.metrics.progress}%</div>\n *     <div>Speed: {(uploadMetrics.metrics.currentSpeed / 1024).toFixed(1)} KB/s</div>\n *     <div>Files: {uploadMetrics.metrics.completedFiles}/{uploadMetrics.metrics.totalFiles}</div>\n *\n *     {uploadMetrics.metrics.estimatedTimeRemaining && (\n *       <div>ETA: {Math.round(uploadMetrics.metrics.estimatedTimeRemaining / 1000)}s</div>\n *     )}\n *\n *     {uploadMetrics.fileMetrics.map((file) => (\n *       <div key={file.id}>\n *         {file.filename}: {file.progress}% ({(file.speed / 1024).toFixed(1)} KB/s)\n *       </div>\n *     ))}\n *   </div>\n * );\n * ```\n */\nexport function useUploadMetrics(\n  options: UseUploadMetricsOptions = {},\n): UseUploadMetricsReturn {\n  const {\n    speedCalculationInterval = 1000,\n    speedSampleSize = 10,\n    onMetricsUpdate,\n    onFileStart,\n    onFileProgress,\n    onFileComplete,\n  } = options;\n\n  const uploadClient = useUploadistaContext();\n\n  const [metrics, setMetrics] = useState<UploadMetrics>(initialMetrics);\n  const [fileMetrics, setFileMetrics] = useState<FileUploadMetrics[]>([]);\n\n  const speedSamplesRef = useRef<Array<{ time: number; bytes: number }>>([]);\n  const lastUpdateRef = useRef<number>(0);\n  const intervalRef = useRef<Timeout | null>(null);\n\n  const calculateSpeed = useCallback(\n    (currentTime: number, totalBytesUploaded: number) => {\n      const sample = { time: currentTime, bytes: totalBytesUploaded };\n      speedSamplesRef.current.push(sample);\n\n      // Keep only recent samples\n      if (speedSamplesRef.current.length > speedSampleSize) {\n        speedSamplesRef.current = speedSamplesRef.current.slice(\n          -speedSampleSize,\n        );\n      }\n\n      // Calculate current speed (bytes per second)\n      let currentSpeed = 0;\n      if (speedSamplesRef.current.length >= 2) {\n        const recent =\n          speedSamplesRef.current[speedSamplesRef.current.length - 1];\n        const previous =\n          speedSamplesRef.current[speedSamplesRef.current.length - 2];\n        if (recent && previous) {\n          const timeDiff = (recent.time - previous.time) / 1000; // Convert to seconds\n          const bytesDiff = recent.bytes - previous.bytes;\n          currentSpeed = timeDiff > 0 ? bytesDiff / timeDiff : 0;\n        }\n      }\n\n      // Calculate average speed\n      let averageSpeed = 0;\n      if (speedSamplesRef.current.length >= 2) {\n        const first = speedSamplesRef.current[0];\n        const last =\n          speedSamplesRef.current[speedSamplesRef.current.length - 1];\n        if (first && last) {\n          const totalTime = (last.time - first.time) / 1000; // Convert to seconds\n          const totalBytes = last.bytes - first.bytes;\n          averageSpeed = totalTime > 0 ? totalBytes / totalTime : 0;\n        }\n      }\n\n      return { currentSpeed, averageSpeed };\n    },\n    [speedSampleSize],\n  );\n\n  const updateMetrics = useCallback(() => {\n    const now = Date.now();\n\n    // Calculate totals from file metrics\n    const totalBytes = fileMetrics.reduce((sum, file) => sum + file.size, 0);\n    const totalBytesUploaded = fileMetrics.reduce(\n      (sum, file) => sum + file.bytesUploaded,\n      0,\n    );\n    const completedFiles = fileMetrics.filter((file) => file.isComplete).length;\n    const activeUploads = fileMetrics.filter(\n      (file) => !file.isComplete && file.bytesUploaded > 0,\n    ).length;\n\n    // Calculate speeds\n    const { currentSpeed, averageSpeed } = calculateSpeed(\n      now,\n      totalBytesUploaded,\n    );\n\n    // Calculate progress\n    const progress =\n      totalBytes > 0 ? Math.round((totalBytesUploaded / totalBytes) * 100) : 0;\n\n    // Calculate estimated time remaining\n    let estimatedTimeRemaining: number | null = null;\n    if (currentSpeed > 0) {\n      const remainingBytes = totalBytes - totalBytesUploaded;\n      estimatedTimeRemaining = (remainingBytes / currentSpeed) * 1000; // Convert to milliseconds\n    }\n\n    // Find start and end times\n    const activeTimes = fileMetrics.filter((file) => file.startTime > 0);\n    const startTime =\n      activeTimes.length > 0\n        ? Math.min(...activeTimes.map((file) => file.startTime))\n        : null;\n\n    const completedTimes = fileMetrics.filter((file) => file.endTime !== null);\n    const endTime =\n      completedTimes.length > 0 && completedFiles === fileMetrics.length\n        ? Math.max(\n            ...completedTimes\n              .map((file) => file.endTime)\n              .filter((time) => time !== null),\n          )\n        : null;\n\n    const totalDuration = startTime && endTime ? endTime - startTime : null;\n\n    const newMetrics: UploadMetrics = {\n      totalBytesUploaded,\n      totalBytes,\n      averageSpeed,\n      currentSpeed,\n      estimatedTimeRemaining,\n      totalFiles: fileMetrics.length,\n      completedFiles,\n      activeUploads,\n      progress,\n      peakSpeed: Math.max(metrics.peakSpeed, currentSpeed),\n      startTime,\n      endTime,\n      totalDuration,\n      insights: uploadClient.client.getChunkingInsights(),\n      sessionMetrics: [uploadClient.client.exportMetrics().session],\n      chunkMetrics: uploadClient.client.exportMetrics().chunks,\n    };\n\n    setMetrics(newMetrics);\n    onMetricsUpdate?.(newMetrics);\n  }, [\n    fileMetrics,\n    metrics.peakSpeed,\n    calculateSpeed,\n    onMetricsUpdate,\n    uploadClient.client,\n  ]);\n\n  // Set up periodic speed calculations\n  const setupSpeedCalculation = useCallback(() => {\n    if (intervalRef.current) {\n      clearInterval(intervalRef.current);\n    }\n\n    intervalRef.current = setInterval(() => {\n      if (\n        fileMetrics.some((file) => !file.isComplete && file.bytesUploaded > 0)\n      ) {\n        updateMetrics();\n      }\n    }, speedCalculationInterval);\n\n    return () => {\n      if (intervalRef.current) {\n        clearInterval(intervalRef.current);\n        intervalRef.current = null;\n      }\n    };\n  }, [speedCalculationInterval, updateMetrics, fileMetrics]);\n\n  const startFileUpload = useCallback(\n    (id: string, filename: string, size: number) => {\n      const now = Date.now();\n\n      const fileMetric: FileUploadMetrics = {\n        id,\n        filename,\n        size,\n        bytesUploaded: 0,\n        progress: 0,\n        speed: 0,\n        startTime: now,\n        endTime: null,\n        duration: null,\n        isComplete: false,\n      };\n\n      setFileMetrics((prev) => {\n        const existing = prev.find((file) => file.id === id);\n        if (existing) {\n          return prev.map((file) => (file.id === id ? fileMetric : file));\n        }\n        return [...prev, fileMetric];\n      });\n\n      onFileStart?.(fileMetric);\n\n      // Start speed calculation if this is the first active upload\n      if (fileMetrics.filter((file) => !file.isComplete).length === 0) {\n        setupSpeedCalculation();\n      }\n    },\n    [fileMetrics, onFileStart, setupSpeedCalculation],\n  );\n\n  const updateFileProgress = useCallback(\n    (id: string, bytesUploaded: number) => {\n      const now = Date.now();\n\n      setFileMetrics((prev) =>\n        prev.map((file) => {\n          if (file.id !== id) return file;\n\n          const timeDiff = (now - file.startTime) / 1000; // seconds\n          const speed = timeDiff > 0 ? bytesUploaded / timeDiff : 0;\n          const progress =\n            file.size > 0 ? Math.round((bytesUploaded / file.size) * 100) : 0;\n\n          const updatedFile = {\n            ...file,\n            bytesUploaded,\n            progress,\n            speed,\n          };\n\n          onFileProgress?.(updatedFile);\n          return updatedFile;\n        }),\n      );\n\n      // Trigger metrics update\n      setTimeout(updateMetrics, 0);\n    },\n    [onFileProgress, updateMetrics],\n  );\n\n  const completeFileUpload = useCallback(\n    (id: string) => {\n      const now = Date.now();\n\n      setFileMetrics((prev) =>\n        prev.map((file) => {\n          if (file.id !== id) return file;\n\n          const duration = now - file.startTime;\n          const speed = duration > 0 ? (file.size / duration) * 1000 : 0; // bytes per second\n\n          const completedFile = {\n            ...file,\n            bytesUploaded: file.size,\n            progress: 100,\n            speed,\n            endTime: now,\n            duration,\n            isComplete: true,\n          };\n\n          onFileComplete?.(completedFile);\n          return completedFile;\n        }),\n      );\n\n      // Trigger metrics update\n      setTimeout(updateMetrics, 0);\n    },\n    [onFileComplete, updateMetrics],\n  );\n\n  const removeFile = useCallback(\n    (id: string) => {\n      setFileMetrics((prev) => prev.filter((file) => file.id !== id));\n      setTimeout(updateMetrics, 0);\n    },\n    [updateMetrics],\n  );\n\n  const reset = useCallback(() => {\n    if (intervalRef.current) {\n      clearInterval(intervalRef.current);\n      intervalRef.current = null;\n    }\n\n    setMetrics(initialMetrics);\n    setFileMetrics([]);\n    speedSamplesRef.current = [];\n    lastUpdateRef.current = 0;\n  }, []);\n\n  const getFileMetrics = useCallback(\n    (id: string) => {\n      return fileMetrics.find((file) => file.id === id);\n    },\n    [fileMetrics],\n  );\n\n  const exportMetrics = useCallback(() => {\n    return {\n      overall: metrics,\n      files: fileMetrics,\n      exportTime: Date.now(),\n    };\n  }, [metrics, fileMetrics]);\n\n  // Cleanup on unmount\n  React.useEffect(() => {\n    return () => {\n      if (intervalRef.current) {\n        clearInterval(intervalRef.current);\n      }\n    };\n  }, []);\n\n  return {\n    metrics,\n    fileMetrics,\n    startFileUpload,\n    updateFileProgress,\n    completeFileUpload,\n    removeFile,\n    reset,\n    getFileMetrics,\n    exportMetrics,\n  };\n}\n","import type { UploadistaEvent } from \"@uploadista/client-core\";\nimport { useEffect } from \"react\";\nimport { useUploadistaContext } from \"../components/uploadista-provider\";\n\n/**\n * Simple hook that subscribes to all Uploadista events (both flow and upload events).\n *\n * This is a low-level hook that provides access to all events. For more structured\n * event handling, consider using `useFlowEvents` or `useUploadEvents` instead.\n *\n * Must be used within UploadistaProvider.\n *\n * @param callback - Function called for every event emitted by the Uploadista client\n *\n * @example\n * ```tsx\n * import { useUploadistaEvents, isFlowEvent, isUploadEvent } from '@uploadista/react';\n *\n * function MyComponent() {\n *   useUploadistaEvents((event) => {\n *     if (isFlowEvent(event)) {\n *       console.log('Flow event:', event.eventType);\n *     } else if (isUploadEvent(event)) {\n *       console.log('Upload event:', event.type);\n *     }\n *   });\n *\n *   return <div>Listening to all events...</div>;\n * }\n * ```\n */\nexport function useUploadistaEvents(\n  callback: (event: UploadistaEvent) => void,\n): void {\n  const { subscribeToEvents } = useUploadistaContext();\n\n  useEffect(() => {\n    const unsubscribe = subscribeToEvents(callback);\n    return unsubscribe;\n  }, [subscribeToEvents, callback]);\n}\n"],"mappings":"yOAOA,SAAgB,EAAY,EAA4C,CACtE,GAAI,EAAE,cAAe,GAAQ,MAAO,GACpC,IAAM,EAAI,EACV,OACE,EAAE,YAAc,EAAU,UAC1B,EAAE,YAAc,EAAU,QAC1B,EAAE,YAAc,EAAU,WAC1B,EAAE,YAAc,EAAU,SAC1B,EAAE,YAAc,EAAU,WAC1B,EAAE,YAAc,EAAU,WAC1B,EAAE,YAAc,EAAU,YAC1B,EAAE,YAAc,EAAU,WAC1B,EAAE,YAAc,EAAU,SAC1B,EAAE,YAAc,EAAU,WAC1B,EAAE,YAAc,EAAU,YAC1B,EAAE,YAAc,EAAU,WAC1B,EAAE,YAAc,EAAU,YAC1B,EAAE,YAAc,EAAU,aAO9B,SAAgB,EAAc,EAA8C,CAC1E,GAAI,EAAE,SAAU,GAAQ,MAAO,GAC/B,IAAM,EAAI,EACV,OACE,EAAE,OAAS,EAAgB,gBAC3B,EAAE,OAAS,EAAgB,iBAC3B,EAAE,OAAS,EAAgB,iBAC3B,EAAE,OAAS,EAAgB,eAC3B,EAAE,OAAS,EAAgB,2BAC3B,EAAE,OAAS,EAAgB,0BAC3B,EAAE,OAAS,EAAgB,0BC+C/B,SAAgB,EAAc,EAAqC,CACjE,GAAM,CAAE,qBAAsB,GAAsB,CAEpD,MACsB,EAAmB,GAAU,CAE1C,KAAY,EAAM,CAGvB,OAAQ,EAAM,UAAd,CACE,KAAK,EAAU,SACb,EAAQ,aAAa,EAAM,CAC3B,MACF,KAAK,EAAU,OACb,EAAQ,WAAW,EAAM,CACzB,MACF,KAAK,EAAU,UACb,EAAQ,cAAc,EAAM,CAC5B,MACF,KAAK,EAAU,QACb,EAAQ,YAAY,EAAM,CAC1B,MACF,KAAK,EAAU,UACb,EAAQ,cAAc,EAAM,CAC5B,MACF,KAAK,EAAU,UACb,EAAQ,cAAc,EAAM,CAC5B,MACF,KAAK,EAAU,WACb,EAAQ,eAAe,EAAM,CAC7B,MACF,KAAK,EAAU,UACb,EAAQ,cAAc,EAAM,CAC5B,MACF,KAAK,EAAU,QACb,EAAQ,YAAY,EAAM,CAC1B,MACF,KAAK,EAAU,UACb,EAAQ,cAAc,EAAM,CAC5B,MACF,KAAK,EAAU,WACb,EAAQ,eAAe,EAAM,CAC7B,MACF,KAAK,EAAU,UACb,EAAQ,cAAc,EAAM,CAC5B,QAEJ,CAGD,CAAC,EAAmB,EAAQ,CAAC,CCMlC,SAAgB,EAAgB,EAAuC,CACrE,GAAM,CAAE,qBAAsB,GAAsB,CAEpD,MACsB,EAAmB,GAAU,CAE/C,GAAI,CAAC,EAAc,EAAM,CAAE,OAI3B,IAAM,EAAc,SAAU,EAAQ,EAAM,KAAO,IAAA,GAEnD,OAAQ,EAAM,KAAd,CACE,KAAK,EAAgB,eACnB,EAAQ,kBAAkB,CACxB,GAAI,EAAM,KACV,KAAM,EACP,CAAC,CACF,MACF,KAAK,EAAgB,gBACnB,EAAQ,mBAAmB,CACzB,GAAI,EAAM,KAIV,KAAM,EACP,CAAC,CACF,MACF,KAAK,EAAgB,gBACnB,EAAQ,mBAAmB,CACzB,GAAI,EAAM,KACV,KAAM,EACP,CAAC,CACF,MACF,KAAK,EAAgB,cACnB,EAAQ,iBAAiB,CACvB,GAAI,EAAM,KACV,KAAM,EACP,CAAC,CACF,MACF,KAAK,EAAgB,0BACnB,EAAQ,4BAA4B,CAClC,GAAI,EAAM,KAIV,KAAM,EACP,CAAC,CACF,MACF,KAAK,EAAgB,yBACnB,EAAQ,2BAA2B,CACjC,GAAI,EAAM,KAIV,KAAM,EACP,CAAC,CACF,MACF,KAAK,EAAgB,0BACnB,EAAQ,4BAA4B,CAClC,GAAI,EAAM,KAIV,KAAM,EACP,CAAC,CACF,QAEJ,CAGD,CAAC,EAAmB,EAAQ,CAAC,CC3BlC,MAAMA,EAAgC,CACpC,mBAAoB,EACpB,WAAY,EACZ,aAAc,EACd,aAAc,EACd,uBAAwB,KACxB,WAAY,EACZ,eAAgB,EAChB,cAAe,EACf,SAAU,EACV,UAAW,EACX,UAAW,KACX,QAAS,KACT,cAAe,KACf,SAAU,CACR,kBAAmB,EACnB,sBAAuB,EACvB,iBAAkB,EAClB,gBAAiB,EAAE,CACnB,sBAAuB,CAAE,IAAK,IAAM,KAAM,IAAK,EAAI,KAAO,KAAM,CACjE,CACD,eAAgB,EAAE,CAClB,aAAc,EAAE,CACjB,CAsDD,SAAgB,EACd,EAAmC,EAAE,CACb,CACxB,GAAM,CACJ,2BAA2B,IAC3B,kBAAkB,GAClB,kBACA,cACA,iBACA,kBACE,EAEE,EAAe,GAAsB,CAErC,CAAC,EAAS,GAAc,EAAwB,EAAe,CAC/D,CAAC,EAAa,GAAkB,EAA8B,EAAE,CAAC,CAEjE,EAAkB,EAA+C,EAAE,CAAC,CACpE,EAAgB,EAAe,EAAE,CACjC,EAAc,EAAuB,KAAK,CAE1C,EAAiB,GACpB,EAAqB,IAA+B,CACnD,IAAM,EAAS,CAAE,KAAM,EAAa,MAAO,EAAoB,CAC/D,EAAgB,QAAQ,KAAK,EAAO,CAGhC,EAAgB,QAAQ,OAAS,IACnC,EAAgB,QAAU,EAAgB,QAAQ,MAChD,CAAC,EACF,EAIH,IAAI,EAAe,EACnB,GAAI,EAAgB,QAAQ,QAAU,EAAG,CACvC,IAAM,EACJ,EAAgB,QAAQ,EAAgB,QAAQ,OAAS,GACrD,EACJ,EAAgB,QAAQ,EAAgB,QAAQ,OAAS,GAC3D,GAAI,GAAU,EAAU,CACtB,IAAM,GAAY,EAAO,KAAO,EAAS,MAAQ,IAC3C,EAAY,EAAO,MAAQ,EAAS,MAC1C,EAAe,EAAW,EAAI,EAAY,EAAW,GAKzD,IAAI,EAAe,EACnB,GAAI,EAAgB,QAAQ,QAAU,EAAG,CACvC,IAAM,EAAQ,EAAgB,QAAQ,GAChC,EACJ,EAAgB,QAAQ,EAAgB,QAAQ,OAAS,GAC3D,GAAI,GAAS,EAAM,CACjB,IAAM,GAAa,EAAK,KAAO,EAAM,MAAQ,IACvC,EAAa,EAAK,MAAQ,EAAM,MACtC,EAAe,EAAY,EAAI,EAAa,EAAY,GAI5D,MAAO,CAAE,eAAc,eAAc,EAEvC,CAAC,EAAgB,CAClB,CAEK,EAAgB,MAAkB,CACtC,IAAM,EAAM,KAAK,KAAK,CAGhB,EAAa,EAAY,QAAQ,EAAK,IAAS,EAAM,EAAK,KAAM,EAAE,CAClE,EAAqB,EAAY,QACpC,EAAK,IAAS,EAAM,EAAK,cAC1B,EACD,CACK,EAAiB,EAAY,OAAQ,GAAS,EAAK,WAAW,CAAC,OAC/D,EAAgB,EAAY,OAC/B,GAAS,CAAC,EAAK,YAAc,EAAK,cAAgB,EACpD,CAAC,OAGI,CAAE,eAAc,gBAAiB,EACrC,EACA,EACD,CAGK,EACJ,EAAa,EAAI,KAAK,MAAO,EAAqB,EAAc,IAAI,CAAG,EAGrEC,EAAwC,KACxC,EAAe,IAEjB,GADuB,EAAa,GACO,EAAgB,KAI7D,IAAM,EAAc,EAAY,OAAQ,GAAS,EAAK,UAAY,EAAE,CAC9D,EACJ,EAAY,OAAS,EACjB,KAAK,IAAI,GAAG,EAAY,IAAK,GAAS,EAAK,UAAU,CAAC,CACtD,KAEA,EAAiB,EAAY,OAAQ,GAAS,EAAK,UAAY,KAAK,CACpE,EACJ,EAAe,OAAS,GAAK,IAAmB,EAAY,OACxD,KAAK,IACH,GAAG,EACA,IAAK,GAAS,EAAK,QAAQ,CAC3B,OAAQ,GAAS,IAAS,KAAK,CACnC,CACD,KAEA,EAAgB,GAAa,EAAU,EAAU,EAAY,KAE7DC,EAA4B,CAChC,qBACA,aACA,eACA,eACA,yBACA,WAAY,EAAY,OACxB,iBACA,gBACA,WACA,UAAW,KAAK,IAAI,EAAQ,UAAW,EAAa,CACpD,YACA,UACA,gBACA,SAAU,EAAa,OAAO,qBAAqB,CACnD,eAAgB,CAAC,EAAa,OAAO,eAAe,CAAC,QAAQ,CAC7D,aAAc,EAAa,OAAO,eAAe,CAAC,OACnD,CAED,EAAW,EAAW,CACtB,IAAkB,EAAW,EAC5B,CACD,EACA,EAAQ,UACR,EACA,EACA,EAAa,OACd,CAAC,CAGI,EAAwB,OACxB,EAAY,SACd,cAAc,EAAY,QAAQ,CAGpC,EAAY,QAAU,gBAAkB,CAEpC,EAAY,KAAM,GAAS,CAAC,EAAK,YAAc,EAAK,cAAgB,EAAE,EAEtE,GAAe,EAEhB,EAAyB,KAEf,CACX,AAEE,EAAY,WADZ,cAAc,EAAY,QAAQ,CACZ,QAGzB,CAAC,EAA0B,EAAe,EAAY,CAAC,CAEpD,EAAkB,GACrB,EAAY,EAAkB,IAAiB,CAG9C,IAAMC,EAAgC,CACpC,KACA,WACA,OACA,cAAe,EACf,SAAU,EACV,MAAO,EACP,UATU,KAAK,KAAK,CAUpB,QAAS,KACT,SAAU,KACV,WAAY,GACb,CAED,EAAgB,GACG,EAAK,KAAM,GAAS,EAAK,KAAO,EAAG,CAE3C,EAAK,IAAK,GAAU,EAAK,KAAO,EAAK,EAAa,EAAM,CAE1D,CAAC,GAAG,EAAM,EAAW,CAC5B,CAEF,IAAc,EAAW,CAGrB,EAAY,OAAQ,GAAS,CAAC,EAAK,WAAW,CAAC,SAAW,GAC5D,GAAuB,EAG3B,CAAC,EAAa,EAAa,EAAsB,CAClD,CAEK,EAAqB,GACxB,EAAY,IAA0B,CACrC,IAAM,EAAM,KAAK,KAAK,CAEtB,EAAgB,GACd,EAAK,IAAK,GAAS,CACjB,GAAI,EAAK,KAAO,EAAI,OAAO,EAE3B,IAAM,GAAY,EAAM,EAAK,WAAa,IACpC,EAAQ,EAAW,EAAI,EAAgB,EAAW,EAClD,EACJ,EAAK,KAAO,EAAI,KAAK,MAAO,EAAgB,EAAK,KAAQ,IAAI,CAAG,EAE5D,EAAc,CAClB,GAAG,EACH,gBACA,WACA,QACD,CAGD,OADA,IAAiB,EAAY,CACtB,GACP,CACH,CAGD,WAAW,EAAe,EAAE,EAE9B,CAAC,EAAgB,EAAc,CAChC,CAEK,EAAqB,EACxB,GAAe,CACd,IAAM,EAAM,KAAK,KAAK,CAEtB,EAAgB,GACd,EAAK,IAAK,GAAS,CACjB,GAAI,EAAK,KAAO,EAAI,OAAO,EAE3B,IAAM,EAAW,EAAM,EAAK,UACtB,EAAQ,EAAW,EAAK,EAAK,KAAO,EAAY,IAAO,EAEvD,EAAgB,CACpB,GAAG,EACH,cAAe,EAAK,KACpB,SAAU,IACV,QACA,QAAS,EACT,WACA,WAAY,GACb,CAGD,OADA,IAAiB,EAAc,CACxB,GACP,CACH,CAGD,WAAW,EAAe,EAAE,EAE9B,CAAC,EAAgB,EAAc,CAChC,CAEK,EAAa,EAChB,GAAe,CACd,EAAgB,GAAS,EAAK,OAAQ,GAAS,EAAK,KAAO,EAAG,CAAC,CAC/D,WAAW,EAAe,EAAE,EAE9B,CAAC,EAAc,CAChB,CAEK,EAAQ,MAAkB,CAC9B,AAEE,EAAY,WADZ,cAAc,EAAY,QAAQ,CACZ,MAGxB,EAAW,EAAe,CAC1B,EAAe,EAAE,CAAC,CAClB,EAAgB,QAAU,EAAE,CAC5B,EAAc,QAAU,GACvB,EAAE,CAAC,CAEA,EAAiB,EACpB,GACQ,EAAY,KAAM,GAAS,EAAK,KAAO,EAAG,CAEnD,CAAC,EAAY,CACd,CAEK,EAAgB,OACb,CACL,QAAS,EACT,MAAO,EACP,WAAY,KAAK,KAAK,CACvB,EACA,CAAC,EAAS,EAAY,CAAC,CAW1B,OARA,EAAM,kBACS,CACP,EAAY,SACd,cAAc,EAAY,QAAQ,EAGrC,EAAE,CAAC,CAEC,CACL,UACA,cACA,kBACA,qBACA,qBACA,aACA,QACA,iBACA,gBACD,CCxiBH,SAAgB,EACd,EACM,CACN,GAAM,CAAE,qBAAsB,GAAsB,CAEpD,MACsB,EAAkB,EAAS,CAE9C,CAAC,EAAmB,EAAS,CAAC"}