@uploadista/react 0.0.17-beta.4 → 0.0.17-beta.6

package/dist/{use-upload-metrics-R1xNz6Aa.d.mts → use-upload-metrics-DhzS4lhG.d.mts}

@@ -1,7 +1,7 @@
-import { FlowEvent, FlowEventFlowCancel, FlowEventFlowEnd, FlowEventFlowError, FlowEventFlowPause, FlowEventFlowStart, FlowEventJobEnd, FlowEventJobStart, FlowEventNodeEnd, FlowEventNodeError, FlowEventNodePause, FlowEventNodeResume, FlowEventNodeStart } from "@uploadista/core/flow";
+import { FlowEvent, FlowEventFlowCancel, FlowEventFlowEnd, FlowEventFlowError, FlowEventFlowPause, FlowEventFlowStart, FlowEventJobEnd, FlowEventJobStart, FlowEventNodeEnd, FlowEventNodeError, FlowEventNodePause, FlowEventNodeResume, FlowEventNodeStart, TypedOutput } from "@uploadista/core/flow";
 import { UploadEvent } from "@uploadista/core/types";
-import { ChunkMetrics, PerformanceInsights, UploadSessionMetrics, UploadistaEvent } from "@uploadista/client-core";
-import { BrowserUploadInput, MultiFlowUploadOptions, MultiFlowUploadState, UploadistaEvent as UploadistaEvent$1 } from "@uploadista/client-browser";
+import { ChunkMetrics, FlowInputs, FlowUploadState, PerformanceInsights, UploadSessionMetrics, UploadistaEvent } from "@uploadista/client-core";
+import { BrowserUploadInput, FlowUploadOptions, MultiFlowUploadOptions, MultiFlowUploadState, UploadistaEvent as UploadistaEvent$1 } from "@uploadista/client-browser";
 
 //#region src/hooks/event-utils.d.ts
 /**
@@ -248,6 +248,208 @@ interface UseUploadEventsOptions {
  */
 declare function useUploadEvents(options: UseUploadEventsOptions): void;
 //#endregion
+//#region src/hooks/use-flow-execution.d.ts
+/**
+ * Input builder function that transforms trigger data into flow inputs.
+ *
+ * The builder receives the trigger data passed to execute() and returns
+ * a FlowInputs object mapping node IDs to their input data.
+ *
+ * @template TTrigger - The type of data passed to execute()
+ * @param trigger - The trigger data (e.g., File, URL string, structured data)
+ * @returns Promise resolving to FlowInputs mapping or the mapping directly
+ *
+ * @example
+ * ```typescript
+ * // File upload builder
+ * const fileBuilder: InputBuilder<File> = async (file) => ({
+ *   "input-node": {
+ *     operation: "init",
+ *     storageId: "s3",
+ *     metadata: { originalName: file.name, size: file.size }
+ *   }
+ * });
+ *
+ * // URL fetch builder
+ * const urlBuilder: InputBuilder<string> = (url) => ({
+ *   "input-node": {
+ *     operation: "url",
+ *     url,
+ *     metadata: { source: "external" }
+ *   }
+ * });
+ * ```
+ */
+type InputBuilder<TTrigger = unknown> = (trigger: TTrigger) => Promise<FlowInputs> | FlowInputs;
+/**
+ * Options for the useFlowExecution hook.
+ *
+ * @template TTrigger - The type of trigger data passed to execute()
+ * @template TOutput - The expected output type from the flow
+ *
+ * @property flowConfig - Flow configuration (flowId, storageId, etc.)
+ * @property inputBuilder - Function to build flow inputs from trigger data
+ * @property onJobStart - Called when flow job is created
+ * @property onProgress - Called during upload progress (if applicable)
+ * @property onChunkComplete - Called when upload chunk completes (if applicable)
+ * @property onSuccess - Called with typed outputs when flow succeeds
+ * @property onFlowComplete - Called with all outputs when flow completes
+ * @property onError - Called when execution fails
+ * @property onAbort - Called when execution is aborted
+ * @property onShouldRetry - Custom retry logic (if applicable)
+ */
+interface UseFlowExecutionOptions<TTrigger = unknown, TOutput = TypedOutput[]> {
+  /**
+   * Flow configuration
+   */
+  flowConfig: FlowUploadOptions["flowConfig"];
+  /**
+   * Function to build flow inputs from trigger data.
+   * Can be async to perform validation, API calls, etc.
+   */
+  inputBuilder: InputBuilder<TTrigger>;
+  /**
+   * Called when the flow job starts
+   */
+  onJobStart?: (jobId: string) => void;
+  /**
+   * Called during upload progress (for file uploads)
+   */
+  onProgress?: (uploadId: string, bytesUploaded: number, totalBytes: number | null) => void;
+  /**
+   * Called when an upload chunk completes (for file uploads)
+   */
+  onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
+  /**
+   * Called when flow execution succeeds with final outputs
+   */
+  onSuccess?: (outputs: TOutput) => void;
+  /**
+   * Called when flow completes (alternative to onSuccess)
+   */
+  onFlowComplete?: (outputs: TypedOutput[]) => void;
+  /**
+   * Called when execution fails
+   */
+  onError?: (error: Error) => void;
+  /**
+   * Called when execution is aborted
+   */
+  onAbort?: () => void;
+  /**
+   * Custom retry logic (for file uploads)
+   */
+  onShouldRetry?: (error: Error, retryAttempt: number) => boolean;
+}
+/**
+ * Return value from useFlowExecution hook.
+ *
+ * @template TTrigger - The type of trigger data passed to execute()
+ *
+ * @property state - Current execution state with progress and outputs
+ * @property execute - Function to trigger flow execution
+ * @property abort - Cancel the current execution
+ * @property pause - Pause the current execution (for file uploads)
+ * @property reset - Reset state to idle
+ * @property isExecuting - True when execution is active
+ * @property isUploadingFile - True during file upload phase
+ * @property isProcessing - True during flow processing phase
+ */
+interface UseFlowExecutionReturn<TTrigger = unknown> {
+  /**
+   * Current execution state
+   */
+  state: FlowUploadState;
+  /**
+   * Execute the flow with trigger data
+   */
+  execute: (trigger: TTrigger) => Promise<void>;
+  /**
+   * Abort the current execution
+   */
+  abort: () => void;
+  /**
+   * Pause the current execution (if supported by input type)
+   */
+  pause: () => void;
+  /**
+   * Reset the execution state
+   */
+  reset: () => void;
+  /**
+   * Whether execution is active (uploading OR processing)
+   */
+  isExecuting: boolean;
+  /**
+   * Whether file upload is in progress
+   */
+  isUploadingFile: boolean;
+  /**
+   * Whether flow processing is in progress
+   */
+  isProcessing: boolean;
+}
+/**
+ * Generic React hook for flexible flow execution.
+ *
+ * Provides a flexible interface for executing flows with arbitrary input types
+ * through an inputBuilder pattern. The builder transforms trigger data into
+ * flow inputs, enabling support for files, URLs, structured data, and more.
+ *
+ * Must be used within FlowManagerProvider (which must be within UploadistaProvider).
+ *
+ * @template TTrigger - The type of trigger data passed to execute()
+ * @template TOutput - The expected output type from the flow
+ *
+ * @param options - Flow execution configuration with inputBuilder
+ * @returns Execution state and control methods
+ *
+ * @example
+ * ```tsx
+ * // URL-based image processing
+ * const urlExecution = useFlowExecution<string>({
+ *   flowConfig: { flowId: "optimize", storageId: "s3" },
+ *   inputBuilder: async (url) => {
+ *     const { inputNodes } = await client.findInputNode("optimize");
+ *     return {
+ *       [inputNodes[0].id]: {
+ *         operation: "url",
+ *         url,
+ *         metadata: { source: "external" }
+ *       }
+ *     };
+ *   },
+ *   onSuccess: (outputs) => console.log("Processed:", outputs)
+ * });
+ *
+ * // Execute with URL
+ * await urlExecution.execute("https://example.com/image.jpg");
+ *
+ * // File upload (traditional pattern)
+ * const fileExecution = useFlowExecution<File>({
+ *   flowConfig: { flowId: "optimize", storageId: "s3" },
+ *   inputBuilder: async (file) => {
+ *     const { inputNodes } = await client.findInputNode("optimize");
+ *     return {
+ *       [inputNodes[0].id]: {
+ *         operation: "init",
+ *         storageId: "s3",
+ *         metadata: {
+ *           originalName: file.name,
+ *           mimeType: file.type,
+ *           size: file.size
+ *         }
+ *       }
+ *     };
+ *   }
+ * });
+ *
+ * // Execute with file
+ * await fileExecution.execute(myFile);
+ * ```
+ */
+declare function useFlowExecution<TTrigger = unknown, TOutput = TypedOutput[]>(options: UseFlowExecutionOptions<TTrigger, TOutput>): UseFlowExecutionReturn<TTrigger>;
+//#endregion
 //#region src/hooks/use-multi-flow-upload.d.ts
 /**
  * Return value from the useMultiFlowUpload hook with batch upload control methods.
@@ -624,5 +826,5 @@ interface UseUploadMetricsReturn {
  */
 declare function useUploadMetrics(options?: UseUploadMetricsOptions): UseUploadMetricsReturn;
 //#endregion
-export { useFlowEvents as _, useUploadMetrics as a, isUploadEvent as b, UploadFailedEventData as c, UploadValidationFailedEventData as d, UploadValidationSuccessEventData as f, UseFlowEventsOptions as g, useUploadEvents as h, UseUploadMetricsReturn as i, UploadFileEventData as l, UseUploadEventsOptions as m, UploadMetrics$1 as n, UseMultiFlowUploadReturn as o, UploadValidationWarningEventData as p, UseUploadMetricsOptions as r, useMultiFlowUpload as s, FileUploadMetrics as t, UploadProgressEventData as u, useUploadistaEvents as v, isFlowEvent as y };
-//# sourceMappingURL=use-upload-metrics-R1xNz6Aa.d.mts.map
+export { isFlowEvent as C, useUploadistaEvents as S, UploadValidationWarningEventData as _, useUploadMetrics as a, UseFlowEventsOptions as b, InputBuilder as c, useFlowExecution as d, UploadFailedEventData as f, UploadValidationSuccessEventData as g, UploadValidationFailedEventData as h, UseUploadMetricsReturn as i, UseFlowExecutionOptions as l, UploadProgressEventData as m, UploadMetrics$1 as n, UseMultiFlowUploadReturn as o, UploadFileEventData as p, UseUploadMetricsOptions as r, useMultiFlowUpload as s, FileUploadMetrics as t, UseFlowExecutionReturn as u, UseUploadEventsOptions as v, isUploadEvent as w, useFlowEvents as x, useUploadEvents as y };
+//# sourceMappingURL=use-upload-metrics-DhzS4lhG.d.mts.map

package/dist/use-upload-metrics-DhzS4lhG.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-upload-metrics-DhzS4lhG.d.mts","names":[],"sources":["../src/hooks/event-utils.ts","../src/hooks/use-uploadista-events.ts","../src/hooks/use-flow-events.ts","../src/hooks/use-upload-events.ts","../src/hooks/use-flow-execution.ts","../src/hooks/use-multi-flow-upload.ts","../src/hooks/use-upload-metrics.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/{use-uploadista-client-ty1ffKD7.d.mts → use-uploadista-client-CfpEI3Us.d.mts}

@@ -1,7 +1,209 @@
 import { UploadFile } from "@uploadista/core/types";
-import { FlowUploadState, FlowUploadStatus, UploadMetrics, UploadState, UploadStatus } from "@uploadista/client-core";
+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 node type */
+  nodeType: 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 {
   /**
@@ -204,6 +406,10 @@ interface UseFlowUploadReturn {
  * 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.
+ *
  * The flow engine processes the uploaded file through a DAG of nodes, which can
  * perform operations like image optimization, storage saving, webhooks, etc.
  *
@@ -213,6 +419,25 @@ 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
@@ -686,5 +911,5 @@ interface UseUploadistaClientReturn {
  */
 declare function useUploadistaClient(options: UseUploadistaClientOptions): UseUploadistaClientReturn;
 //#endregion
-export { 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, useDragDrop as x, DragDropState as y };
-//# sourceMappingURL=use-uploadista-client-ty1ffKD7.d.mts.map
+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-CfpEI3Us.d.mts.map

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

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

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/react",
   "type": "module",
-  "version": "0.0.17-beta.4",
+  "version": "0.0.17-beta.6",
   "description": "React client for Uploadista",
   "license": "MIT",
   "author": "Uploadista",
@@ -22,16 +22,16 @@
   "dependencies": {
     "react": "19.2.0",
     "react-dom": "19.2.0",
-    "@uploadista/core": "0.0.17-beta.4",
-    "@uploadista/client-core": "0.0.17-beta.4",
-    "@uploadista/client-browser": "0.0.17-beta.4"
+    "@uploadista/core": "0.0.17-beta.6",
+    "@uploadista/client-core": "0.0.17-beta.6",
+    "@uploadista/client-browser": "0.0.17-beta.6"
   },
   "devDependencies": {
     "@types/react": "19.2.6",
     "@types/react-dom": "19.2.3",
     "tsdown": "0.16.5",
     "vitest": "4.0.10",
-    "@uploadista/typescript-config": "0.0.17-beta.4"
+    "@uploadista/typescript-config": "0.0.17-beta.6"
   },
   "scripts": {
     "build": "tsdown",