@uploadista/vue 1.0.0-beta.3 → 1.0.0

package/dist/{useUploadMetrics-DEdjOjLp.d.mts → index-BlM5dmy_.d.mts}

@@ -1,12 +1,8 @@
-import * as vue from "vue";
 import { App, InjectionKey, Ref } from "vue";
-import * as _uploadista_client_browser0 from "@uploadista/client-browser";
 import { BrowserUploadInput, ChunkMetrics, ChunkMetrics as ChunkMetrics$1, FlowUploadOptions, MultiFlowUploadOptions, PerformanceInsights, PerformanceInsights as PerformanceInsights$1, UploadOptions, UploadSessionMetrics, UploadSessionMetrics as UploadSessionMetrics$1, UploadistaClientOptions, UploadistaEvent, createUploadistaClient } from "@uploadista/client-browser";
 import { FlowEvent, FlowEventFlowCancel, FlowEventFlowEnd, FlowEventFlowError, FlowEventFlowPause, FlowEventFlowStart, FlowEventJobEnd, FlowEventJobStart, FlowEventNodeEnd, FlowEventNodeError, FlowEventNodePause, FlowEventNodeResume, FlowEventNodeStart } from "@uploadista/core/flow";
 import { UploadEvent, UploadFile } from "@uploadista/core/types";
-import * as _uploadista_client_core0 from "@uploadista/client-core";
 import { FlowUploadState, FlowUploadStatus as FlowUploadStatus$1, InputExecutionState, UploadMetrics, UploadOptions as UploadOptions$1, UploadState, UploadStatus } from "@uploadista/client-core";
-import * as _uploadista_core0 from "@uploadista/core";
 
 //#region src/composables/useFlow.d.ts
 /**
@@ -341,7 +337,7 @@ interface DragDropState {
  * ```
  */
 declare function useDragDrop(options?: DragDropOptions): {
-  state: Readonly<vue.Ref<{
+  state: Readonly<import("vue").Ref<{
     readonly isDragging: boolean;
     readonly isOver: boolean;
     readonly isValid: boolean;
@@ -357,7 +353,7 @@ declare function useDragDrop(options?: DragDropOptions): {
   onDragLeave: (event: DragEvent) => void;
   onDrop: (event: DragEvent) => void;
   onInputChange: (event: Event) => void;
-  inputProps: vue.ComputedRef<{
+  inputProps: import("vue").ComputedRef<{
     type: "file";
     multiple: boolean;
     accept: string | undefined;
@@ -709,7 +705,7 @@ declare function createUploadistaPlugin(options: UploadistaPluginOptions): {
  * ```
  */
 declare function useMultiFlowUpload(options: MultiFlowUploadOptions<BrowserUploadInput>): {
-  state: Readonly<vue.Ref<{
+  state: Readonly<import("vue").Ref<{
     readonly items: readonly {
       readonly id: string;
       readonly file: {
@@ -855,7 +851,7 @@ declare function useMultiFlowUpload(options: MultiFlowUploadOptions<BrowserUploa
   abortAll: () => void;
   clear: () => void;
   retryUpload: (id: string) => void;
-  isUploading: vue.ComputedRef<boolean>;
+  isUploading: import("vue").ComputedRef<boolean>;
 };
 //#endregion
 //#region src/composables/useUpload.d.ts
@@ -898,7 +894,7 @@ type UploadInput = File | Blob;
  * ```
  */
 declare function useUpload(options?: UploadOptions$1): {
-  state: vue.Ref<{
+  state: import("vue").Ref<{
     status: UploadStatus;
     progress: number;
     bytesUploaded: number;
@@ -925,7 +921,7 @@ declare function useUpload(options?: UploadOptions$1): {
         jobId: string;
       } | undefined;
       size?: number | undefined | undefined;
-      metadata?: Record<string, _uploadista_core0.JsonValue> | undefined;
+      metadata?: Record<string, import("@uploadista/core").JsonValue> | undefined;
       creationDate?: string | undefined | undefined;
       url?: string | undefined | undefined;
       sizeIsDeferred?: boolean | undefined | undefined;
@@ -964,7 +960,7 @@ declare function useUpload(options?: UploadOptions$1): {
         jobId: string;
       } | undefined;
       size?: number | undefined | undefined;
-      metadata?: Record<string, _uploadista_core0.JsonValue> | undefined;
+      metadata?: Record<string, import("@uploadista/core").JsonValue> | undefined;
       creationDate?: string | undefined | undefined;
       url?: string | undefined | undefined;
       sizeIsDeferred?: boolean | undefined | undefined;
@@ -981,8 +977,8 @@ declare function useUpload(options?: UploadOptions$1): {
   abort: () => void;
   reset: () => void;
   retry: () => void;
-  isUploading: vue.ComputedRef<boolean>;
-  canRetry: vue.ComputedRef<boolean>;
+  isUploading: import("vue").ComputedRef<boolean>;
+  canRetry: import("vue").ComputedRef<boolean>;
   metrics: UploadMetrics;
 };
 //#endregion
@@ -1125,7 +1121,7 @@ interface MultiUploadState {
  * ```
  */
 declare function useMultiUpload(options?: MultiUploadOptions): {
-  state: Readonly<vue.Ref<{
+  state: Readonly<import("vue").Ref<{
     readonly total: number;
     readonly completed: number;
     readonly successful: number;
@@ -1148,7 +1144,7 @@ declare function useMultiUpload(options?: MultiUploadOptions): {
     readonly isUploading: boolean;
     readonly isComplete: boolean;
   }>>;
-  items: Readonly<vue.Ref<readonly {
+  items: Readonly<import("vue").Ref<readonly {
     readonly id: string;
     readonly file: {
       readonly lastModified: number;
@@ -1336,7 +1332,7 @@ declare function useMultiUpload(options?: MultiUploadOptions): {
           jobId: string;
         } | undefined;
         size?: number | undefined | undefined;
-        metadata?: Record<string, _uploadista_core0.JsonValue> | undefined;
+        metadata?: Record<string, import("@uploadista/core").JsonValue> | undefined;
         creationDate?: string | undefined | undefined;
         url?: string | undefined | undefined;
         sizeIsDeferred?: boolean | undefined | undefined;
@@ -1382,7 +1378,7 @@ declare function useMultiUpload(options?: MultiUploadOptions): {
  */
 declare function useUploadistaClient(): {
   client: {
-    upload: (file: _uploadista_client_browser0.BrowserUploadInput, {
+    upload: (file: import("@uploadista/client-browser").BrowserUploadInput, {
       uploadLengthDeferred,
       uploadSize,
       onProgress,
@@ -1390,10 +1386,10 @@ declare function useUploadistaClient(): {
       onSuccess,
       onShouldRetry,
       onError
-    }?: _uploadista_client_core0.UploadistaUploadOptions) => Promise<{
+    }?: import("@uploadista/client-core").UploadistaUploadOptions) => Promise<{
       abort: () => void;
     }>;
-    uploadWithFlow: (file: _uploadista_client_browser0.BrowserUploadInput, flowConfig: _uploadista_client_core0.FlowUploadConfig, {
+    uploadWithFlow: (file: import("@uploadista/client-browser").BrowserUploadInput, flowConfig: import("@uploadista/client-core").FlowUploadConfig, {
       onProgress,
       onChunkComplete,
       onSuccess,
@@ -1401,7 +1397,7 @@ declare function useUploadistaClient(): {
       onJobStart,
       onError,
       onAbort
-    }?: Omit<_uploadista_client_core0.UploadistaUploadOptions, "uploadLengthDeferred" | "uploadSize" | "metadata"> & {
+    }?: Omit<import("@uploadista/client-core").UploadistaUploadOptions, "uploadLengthDeferred" | "uploadSize" | "metadata"> & {
       onAbort?: () => void;
     }) => Promise<{
       abort: () => Promise<void>;
@@ -1409,7 +1405,7 @@ declare function useUploadistaClient(): {
       resume: () => Promise<void>;
       jobId: string;
     }>;
-    multiInputFlowUpload: (inputs: Record<string, unknown>, flowConfig: _uploadista_client_core0.FlowUploadConfig, {
+    multiInputFlowUpload: (inputs: Record<string, unknown>, flowConfig: import("@uploadista/client-core").FlowUploadConfig, {
       onProgress,
       onChunkComplete,
       onShouldRetry,
@@ -1418,7 +1414,7 @@ declare function useUploadistaClient(): {
       onInputProgress,
       onInputComplete,
       onInputError
-    }?: Omit<_uploadista_client_core0.UploadistaUploadOptions, "uploadLengthDeferred" | "uploadSize" | "metadata"> & {
+    }?: Omit<import("@uploadista/client-core").UploadistaUploadOptions, "uploadLengthDeferred" | "uploadSize" | "metadata"> & {
       onInputProgress?: (nodeId: string, progress: number, bytesUploaded: number, totalBytes: number | null) => void;
       onInputComplete?: (nodeId: string) => void;
       onInputError?: (nodeId: string, error: Error) => void;
@@ -1441,17 +1437,17 @@ declare function useUploadistaClient(): {
     }: {
       uploadId: string;
       uploadIdStorageKey: string | undefined;
-      retryTimeout: _uploadista_client_core0.Timeout | null;
+      retryTimeout: import("@uploadista/client-core").Timeout | null;
       shouldTerminate: boolean;
-      abortController: _uploadista_client_core0.AbortControllerLike;
-      uploadistaApi: _uploadista_client_core0.UploadistaApi;
-      platformService: _uploadista_client_core0.PlatformService;
+      abortController: import("@uploadista/client-core").AbortControllerLike;
+      uploadistaApi: import("@uploadista/client-core").UploadistaApi;
+      platformService: import("@uploadista/client-core").PlatformService;
       retryDelays?: number[];
-      clientStorage: _uploadista_client_core0.ClientStorage;
+      clientStorage: import("@uploadista/client-core").ClientStorage;
     }) => Promise<void>>[0]) => Promise<void>;
     getFlow: (flowId: string) => Promise<{
       status: number;
-      flow: _uploadista_core0.FlowData;
+      flow: import("@uploadista/core").FlowData;
     }>;
     runFlow: ({
       flowId,
@@ -1463,7 +1459,7 @@ declare function useUploadistaClient(): {
       storageId?: string;
     }) => Promise<{
       status: number;
-      job: _uploadista_core0.FlowJob;
+      job: import("@uploadista/core").FlowJob;
     }>;
     resumeFlow: ({
       jobId,
@@ -1475,13 +1471,13 @@ declare function useUploadistaClient(): {
       nodeId: string;
       newData: unknown;
       contentType?: "application/json" | "application/octet-stream";
-    }) => Promise<_uploadista_core0.FlowJob>;
-    pauseFlow: (jobId: string) => Promise<_uploadista_core0.FlowJob>;
-    cancelFlow: (jobId: string) => Promise<_uploadista_core0.FlowJob>;
+    }) => Promise<import("@uploadista/core").FlowJob>;
+    pauseFlow: (jobId: string) => Promise<import("@uploadista/core").FlowJob>;
+    cancelFlow: (jobId: string) => Promise<import("@uploadista/core").FlowJob>;
     findInputNode: (flowId: string) => Promise<{
       inputNodes: {
         id: string;
-        type: _uploadista_core0.NodeType;
+        type: import("@uploadista/core").NodeType;
         name: string;
       }[];
       single: boolean;
@@ -1491,12 +1487,12 @@ declare function useUploadistaClient(): {
       onJobStart?: (jobId: string) => void;
     }) => Promise<{
       status: number;
-      job: _uploadista_core0.FlowJob;
+      job: import("@uploadista/core").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>;
+    getJobStatus: (jobId: string) => Promise<import("@uploadista/core").FlowJob>;
+    openUploadWebSocket: (uploadId: string) => Promise<import("@uploadista/client-core").WebSocketLike>;
+    openFlowWebSocket: (jobId: string) => Promise<import("@uploadista/client-core").WebSocketLike>;
+    openWebSocket: (id: string) => Promise<import("@uploadista/client-core").WebSocketLike>;
     closeWebSocket: (id: string) => void;
     closeAllWebSockets: () => void;
     sendPing: (jobId: string) => boolean;
@@ -1507,16 +1503,16 @@ declare function useUploadistaClient(): {
       flow: number;
       total: number;
     };
-    getNetworkMetrics: () => _uploadista_client_core0.NetworkMetrics;
-    getNetworkCondition: () => _uploadista_client_core0.NetworkCondition;
-    getChunkingInsights: () => _uploadista_client_core0.PerformanceInsights;
+    getNetworkMetrics: () => import("@uploadista/client-core").NetworkMetrics;
+    getNetworkCondition: () => import("@uploadista/client-core").NetworkCondition;
+    getChunkingInsights: () => import("@uploadista/client-core").PerformanceInsights;
     exportMetrics: () => {
-      session: Partial<_uploadista_client_core0.UploadSessionMetrics>;
-      chunks: _uploadista_client_core0.ChunkMetrics[];
-      insights: _uploadista_client_core0.PerformanceInsights;
+      session: Partial<import("@uploadista/client-core").UploadSessionMetrics>;
+      chunks: import("@uploadista/client-core").ChunkMetrics[];
+      insights: import("@uploadista/client-core").PerformanceInsights;
     };
-    getConnectionMetrics: () => _uploadista_client_core0.ConnectionMetrics;
-    getDetailedConnectionMetrics: () => _uploadista_client_core0.DetailedConnectionMetrics;
+    getConnectionMetrics: () => import("@uploadista/client-core").ConnectionMetrics;
+    getDetailedConnectionMetrics: () => import("@uploadista/client-core").DetailedConnectionMetrics;
     warmupConnections: (urls: string[]) => Promise<void>;
     getConnectionPoolingInsights: () => Promise<{
       isOptimized: boolean;
@@ -1525,18 +1521,18 @@ declare function useUploadistaClient(): {
       connectionOverhead: number;
     }>;
     resetMetrics: () => Promise<void>;
-    validateConfiguration: (options: _uploadista_client_core0.UploadistaClientOptions<_uploadista_client_browser0.BrowserUploadInput>) => {
+    validateConfiguration: (options: import("@uploadista/client-core").UploadistaClientOptions<import("@uploadista/client-browser").BrowserUploadInput>) => {
       valid: boolean;
       errors: string[];
       warnings: string[];
     };
-    validateConfigurationAsync: (options: _uploadista_client_core0.UploadistaClientOptions<_uploadista_client_browser0.BrowserUploadInput>) => Promise<{
+    validateConfigurationAsync: (options: import("@uploadista/client-core").UploadistaClientOptions<import("@uploadista/client-browser").BrowserUploadInput>) => Promise<{
       valid: boolean;
       errors: string[];
       warnings: string[];
-      capabilities: _uploadista_core0.DataStoreCapabilities;
+      capabilities: import("@uploadista/core").DataStoreCapabilities;
     }>;
-    getCapabilities: () => Promise<_uploadista_core0.DataStoreCapabilities>;
+    getCapabilities: () => Promise<import("@uploadista/core").DataStoreCapabilities>;
   };
   subscribeToEvents: (handler: (event: UploadistaEvent) => void) => () => void;
 };
@@ -1701,7 +1697,7 @@ interface UseUploadMetricsOptions {
  * ```
  */
 declare function useUploadMetrics(options?: UseUploadMetricsOptions): {
-  metrics: Readonly<vue.Ref<{
+  metrics: Readonly<import("vue").Ref<{
     readonly totalBytesUploaded: number;
     readonly totalBytes: number;
     readonly averageSpeed: number;
@@ -1802,7 +1798,7 @@ declare function useUploadMetrics(options?: UseUploadMetricsOptions): {
       readonly chunkingStrategy?: string | undefined;
     }[];
   }>>;
-  fileMetrics: Readonly<vue.Ref<readonly {
+  fileMetrics: Readonly<import("vue").Ref<readonly {
     readonly id: string;
     readonly filename: string;
     readonly size: number;
@@ -1911,4 +1907,4 @@ declare function useUploadMetrics(options?: UseUploadMetricsOptions): {
 };
 //#endregion
 export { UseFlowEventsOptions as A, InputExecutionState as B, UploadFileEventData as C, UploadValidationWarningEventData as D, UploadValidationSuccessEventData as E, DragDropState as F, useFlow as H, useDragDrop as I, FlowInputMetadata as L, isFlowEvent as M, isUploadEvent as N, UseUploadEventsOptions as O, DragDropOptions as P, FlowUploadState as R, UploadFailedEventData as S, UploadValidationFailedEventData as T, UseFlowReturn as V, useMultiFlowUpload as _, useUploadistaClient as a, createUploadistaPlugin as b, UploadItem as c, PerformanceInsights$1 as d, UploadInput as f, useUpload as g, UploadStatus as h, UseUploadistaClientReturn as i, useFlowEvents as j, useUploadEvents as k, useMultiUpload as l, UploadState as m, UseUploadMetricsOptions as n, MultiUploadOptions as o, UploadSessionMetrics$1 as p, useUploadMetrics as r, MultiUploadState as s, FileUploadMetrics as t, ChunkMetrics$1 as u, UPLOADISTA_CLIENT_KEY as v, UploadProgressEventData as w, useUploadistaEvents as x, UploadistaPluginOptions as y, FlowUploadStatus$1 as z };
-//# sourceMappingURL=useUploadMetrics-DEdjOjLp.d.mts.map
+//# sourceMappingURL=index-BlM5dmy_.d.mts.map

package/dist/index-BlM5dmy_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BlM5dmy_.d.mts","names":[],"sources":["../src/composables/useFlow.ts","../src/composables/useDragDrop.ts","../src/composables/eventUtils.ts","../src/composables/useFlowEvents.ts","../src/composables/useUploadEvents.ts","../src/composables/useUploadistaEvents.ts","../src/composables/plugin.ts","../src/composables/useMultiFlowUpload.ts","../src/composables/useUpload.ts","../src/composables/useMultiUpload.ts","../src/composables/useUploadistaClient.ts","../src/composables/useUploadMetrics.ts"],"mappings":";;;;;;;;;;UA0BiB,iBAAA;EAAiB;EAEhC,MAAA;EAFgC;EAIhC,QAAA;EAAA;EAEA,eAAA;EAEA;EAAA,WAAA;EAEQ;EAAR,QAAA;AAAA;;;;;;;;;;;;;;;;;;;UAqBe,aAAA;EAiDF;;;EA7Cb,KAAA,EAAO,QAAA,CAAS,GAAA,CAAI,eAAA;EAiEP;;;EA5Db,aAAA,EAAe,QAAA,CAAS,GAAA,CAAI,iBAAA;EAsEd;;;EAjEd,WAAA,EAAa,QAAA,CAAS,GAAA,CAAI,WAAA,SAAoB,mBAAA;EA2EpC;;;EAtEV,MAAA,EAAQ,QAAA,CAAS,GAAA,CAAI,MAAA;EAfd;;;;;;;EAwBP,QAAA,GAAW,MAAA,UAAgB,KAAA;EAdd;;;;;;EAsBb,OAAA,QAAe,OAAA;EAjBM;;;;;;EAyBrB,MAAA,GAAS,IAAA,EAAM,IAAA,GAAO,IAAA,KAAS,OAAA;EAAhB;;;EAKf,KAAA,QAAa,OAAA;EAAb;;;EAKA,KAAA,QAAa,OAAA;EAKb;;;EAAA,MAAA,QAAc,OAAA;EAUD;;;EALb,KAAA;EAU0B;;;EAL1B,WAAA,EAAa,QAAA,CAAS,GAAA;EAetB;;;EAVA,eAAA,EAAiB,QAAA,CAAS,GAAA;EAehB;;;EAVV,YAAA,EAAc,QAAA,CAAS,GAAA;EA4HT;;;EAvHd,mBAAA,EAAqB,QAAA,CAAS,GAAA;EAuHC;;;EAlH/B,QAAA,EAAU,QAAA,CAAS,GAAA;AAAA;;;;AChJrB;;;;;;;;;;;;;;;;;;;AAuC0C;AAG1C;;;;;;;;;AAmBiB;AAgFjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzIA;;;;;;;;AAA+D;iBF8P/C,OAAA,CAAQ,OAAA,EAAS,iBAAA,GAAoB,aAAa;;;UClQjD,eAAA;;;;EAIf,MAAA;;;ADoBF;ECfE,QAAA;;;;EAKA,WAAA;EDgBA;;;ECXA,QAAA;EDeQ;AAqBV;;EC/BE,SAAA,IAAa,KAAA,EAAO,IAAA;EDmCA;;;EC9BpB,eAAA,IAAmB,KAAA,EAAO,IAAI;EDmCN;;;EC9BxB,iBAAA,IAAqB,MAAA;EDmCC;;;EC9BtB,iBAAA,IAAqB,UAAA;AAAA;AAAA,UAGN,aAAA;EDyDA;;;EAAA,SCrDN,UAAA;ED+DI;;;EAAA,SC1DJ,MAAA;ED8EiB;;;EAAA,SCzEjB,OAAA;EDmFqB;;;EAAA,SC9ErB,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ADmFa;AAkHxB;;;;;;;;AAAkE;;;;AClQlE;;;;;;iBA6IgB,WAAA,CAAY,OAAA,GAAS,eAAA;;;;;;;;;;;;uBAoHP,SAAA;sBAYD,SAAA;uBAUC,SAAA;kBAYL,SAAA;yBAgBO,KAAA;;;;;;wBA1FD,IAAA;;;;;;;;iBCrNf,WAAA,CAAY,KAAA,YAAiB,KAAA,IAAS,SAAS;;AFoB/D;;iBEKgB,aAAA,CAAc,KAAA,YAAiB,KAAA,IAAS,WAAW;;;;;;;;UCNlD,oBAAA;EHCA;EGCf,UAAA,IAAc,KAAA,EAAO,iBAAA;;EAErB,QAAA,IAAY,KAAA,EAAO,eAAA;EHDnB;EGGA,WAAA,IAAe,KAAA,EAAO,kBAAA;EHCtB;EGCA,SAAA,IAAa,KAAA,EAAO,gBAAA;EHGpB;EGDA,WAAA,IAAe,KAAA,EAAO,kBAAA;EHCd;EGCR,WAAA,IAAe,KAAA,EAAO,kBAAA;EHoBM;EGlB5B,YAAA,IAAgB,KAAA,EAAO,mBAAA;EHsBH;EGpBpB,WAAA,IAAe,KAAA,EAAO,kBAAA;EHoBf;EGlBP,SAAA,IAAa,KAAA,EAAO,gBAAA;EHuBI;EGrBxB,WAAA,IAAe,KAAA,EAAO,kBAAA;EH0BwB;EGxB9C,YAAA,IAAgB,KAAA,EAAO,mBAAA;EHwBD;EGtBtB,WAAA,IAAe,KAAA,EAAO,kBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0CR,aAAA,CAAc,OAA6B,EAApB,oBAAoB;;;;;;UClF1C,uBAAA;EACf,EAAA;EACA,QAAA;EACA,KAAA;EACA,IAAA;IACE,MAAA;IACA,MAAA;IACA,KAAA;EAAA;AAAA;;;;UAOa,mBAAA;EAAA,CAEd,GAAA;EACD,IAAA;IACE,MAAA;IACA,MAAA;IACA,KAAA;EAAA;AAAA;;;;UAOa,qBAAA;EACf,EAAA;EACA,KAAA;EACA,IAAA;IACE,MAAA;IACA,MAAA;IACA,KAAA;EAAA;AAAA;;;;UAOa,gCAAA;EACf,EAAA;EACA,cAAA;EACA,SAAA;EACA,IAAA;IACE,MAAA;IACA,MAAA;IACA,KAAA;EAAA;AAAA;;;;UAOa,+BAAA;EACf,EAAA;EACA,MAAA;EACA,QAAA;EACA,MAAA;EACA,IAAA;IACE,MAAA;IACA,MAAA;IACA,KAAA;EAAA;AAAA;;;;UAOa,gCAAA;EACf,EAAA;EACA,OAAA;EACA,IAAA;IACE,MAAA;IACA,MAAA;IACA,KAAA;EAAA;AAAA;;;;;;UASa,sBAAA;EJaF;EIXb,eAAA,IAAmB,IAAA,EAAM,mBAAA;EJgBZ;EIdb,gBAAA,IAAoB,IAAA,EAAM,uBAAA;EJmBZ;EIjBd,gBAAA,IAAoB,IAAA,EAAM,mBAAA;EJ2B1B;EIzBA,cAAA,IAAkB,IAAA,EAAM,qBAAA;EJyBF;EIvBtB,yBAAA,IAA6B,IAAA,EAAM,gCAAA;EJ4BlB;EI1BjB,wBAAA,IAA4B,IAAA,EAAM,+BAAA;EJ+BlC;EI7BA,yBAAA,IAA6B,IAAA,EAAM,gCAAA;AAAA;;;;;;;;AJuCb;AAkHxB;;;;;;;;AAAkE;;;;AClQlE;;;;;;;;;;;;;;;;;iBGiJgB,eAAA,CAAgB,OAA+B,EAAtB,sBAAsB;;;;;;;;;AJzH/D;;;;;;;;;;AAUU;AAqBV;;;;;;;;;;;;iBKxBgB,mBAAA,CACd,QAAA,GAAW,KAAA,EAAO,eAAe;;;UC1BlB,uBAAA,SAAgC,uBAAuB;;;;EAItE,OAAA,GAAU,uBAAA;AAAA;AAAA,cAGC,qBAAA,EAAuB,YAAA,CAClC,UAAA,QAAkB,sBAAA;;;;;;;;ANoBV;AAqBV;;;;;;;;;;;;;;;;;;;;;iBMLgB,sBAAA,CAAuB,OAAA,EAAS,uBAAA;eAE/B,GAAG;AAAA;;;;;;;;;AN5BpB;;;;;;;;;;AAUU;AAqBV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBOCgB,kBAAA,CACd,OAAA,EAAS,sBAAA,CAAuB,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAmJP,IAAA,KAAS,QAAA;;;;;;;;;;;KC1LxB,WAAA,GAAc,IAAA,GAAO,IAAI;;ARMrC;;;;;;;;;;AAUU;AAqBV;;;;;;;;;;;;;;;;;;;;;;;;;iBQYgB,SAAA,CAAU,OAAA,GAAS,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCX,WAAA;;;;;;;;;;UC/FP,UAAA;EACf,EAAA;EACA,IAAA,EAAM,WAAA;EACN,KAAA,EAAO,WAAW;AAAA;AAAA,UAGH,kBAAA,SACP,IAAA,CAAK,aAAA;ETYmB;;;ESRhC,aAAA;ETgBA;;;ESXA,aAAA,IAAiB,IAAA,EAAM,UAAA;ETkCR;;;ES7Bf,gBAAA,IACE,IAAA,EAAM,UAAA,EACN,QAAA,UACA,aAAA,UACA,UAAA;ET6Bc;;;ESvBhB,eAAA,IAAmB,IAAA,EAAM,UAAA,EAAY,MAAA,EAAQ,UAAA;ET4B9B;;;ESvBf,aAAA,IAAiB,IAAA,EAAM,UAAA,EAAY,KAAA,EAAO,KAAA;ET4B7B;;;ESvBb,UAAA,IAAc,OAAA;IACZ,UAAA,EAAY,UAAA;IACZ,MAAA,EAAQ,UAAA;IACR,KAAA;EAAA;AAAA;AAAA,UAIa,gBAAA;ET6DD;;;ESzDd,KAAA;ETwEiB;;;ESnEjB,SAAA;ET6EqB;;;ESxErB,UAAA;ET6EkB;;;ESxElB,MAAA;ETboB;;;ESkBpB,SAAA;ETb4B;;;ESkB5B,QAAA;ETb0B;;;ESkB1B,kBAAA;ETbiB;;;ESkBjB,UAAA;ETT2B;;;ESc3B,WAAA;ETEe;;;ESGf,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;AT0CsB;AAkHxB;;;;;;;;AAAkE;;;;AClQlE;;;;;;;;;;;;;;;;;;;AAuC0C;AAG1C;;;;;iBQ2HgB,cAAA,CAAe,OAAA,GAAS,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA6Mb,WAAA;;;;;;;;;;6BA4IS,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ATtepC;;;;;;;;;;AAUU;AAqBV;;;;;;;;;iBUxBgB,mBAAA;;;;;;;;;;0CAwCy1F,uBAAA,KAAA,OAAA;;;;;;;;;;;QAA0U,IAAA,mCAAA,uBAAA;;;;;;;;;;;;;;;;;QAAgjB,IAAA,mCAAA,uBAAA;yBAA8I,MAAA,UAAA,QAAA,UAAA,aAAA,UAAA,UAAA;yBAAoH,MAAA;sBAA6C,MAAA,UAAA,KAAA,EAAA,KAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA+8D,KAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAxB17L,KAAA,EAAO,eAAA;AAAA;AAAA,KAuBlC,yBAAA,GAA4B,UAAU,QAAQ,mBAAA;;;UChEzC,eAAA;;;;EAIf,kBAAA;;AXcF;;EWTE,UAAA;EXSgC;;;EWJhC,YAAA;EXYA;;;EWPA,YAAA;EX8Be;;;EWzBf,sBAAA;EX6BgB;;;EWxBhB,UAAA;EX6Be;;;EWxBf,cAAA;EX6Ba;;;EWxBb,aAAA;EX8Ce;;;EWzCf,QAAA;EXsDa;;;EWjDb,SAAA;EXqEa;;;EWhEb,SAAA;EX0Ec;;;EWrEd,OAAA;EX+EU;;;EW1EV,aAAA;EXXO;;;EWgBP,QAAA,EAAU,mBAAA;EXXK;;;EWgBf,cAAA,EAAgB,OAAA,CAAQ,oBAAA;EXXX;;;EWgBb,YAAA,EAAc,YAAA;AAAA;AAAA,UAGC,iBAAA;EACf,EAAA;EACA,QAAA;EACA,IAAA;EACA,aAAA;EACA,QAAA;EACA,KAAA;EACA,SAAA;EACA,OAAA;EACA,QAAA;EACA,UAAA;AAAA;AAAA,UAGe,uBAAA;EXGf;;;EWCA,wBAAA;EXSA;;;EWJA,eAAA;EXca;;;EWTb,eAAA,IAAmB,OAAA,EAAS,eAAA;EXcF;;;EWT1B,WAAA,IAAe,WAAA,EAAa,iBAAA;EXmB5B;;;EWdA,cAAA,IAAkB,WAAA,EAAa,iBAAA;EXmBrB;;;EWdV,cAAA,IAAkB,WAAA,EAAa,iBAAA;AAAA;;;;;;;;AXgIiC;;;;AClQlE;;;;;;;;;;;;;;;;;;;AAuC0C;AAG1C;;;;;;;;;AAmBiB;AAgFjB;;;;;;;;;;;;iBUsEgB,gBAAA,CAAiB,OAAA,GAAS,uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAwJL,QAAA,UAAkB,IAAA;mCAiCf,aAAA"}

package/dist/{UploadistaProvider.vue-_qDn5Gvp.d.mts → index-DcNYDFLL.d.mts}

@@ -1,11 +1,9 @@
-import * as vue from "vue";
-
 //#region src/providers/FlowManagerProvider.vue.d.ts
 declare var __VLS_1: {};
 type __VLS_Slots$1 = {} & {
   default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_base$1: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const __VLS_base$1: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
 declare const _default$1: typeof __VLS_export$1;
 type __VLS_WithSlots$1<T, S> = T & {
@@ -27,13 +25,13 @@ declare var __VLS_8: {};
 type __VLS_Slots = {} & {
   default?: (props: typeof __VLS_8) => any;
 };
-declare const __VLS_base: vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-  uploadistaBasePath: string;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
   storageId: string;
+  uploadistaBasePath: string;
   chunkSize: number;
   parallelUploads: number;
   storeFingerprintForResuming: boolean;
-}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 type __VLS_WithSlots<T, S> = T & {
@@ -43,4 +41,4 @@ type __VLS_WithSlots<T, S> = T & {
 }; //# sourceMappingURL=UploadistaProvider.vue.d.ts.map
 //#endregion
 export { _default$1 as n, _default as t };
-//# sourceMappingURL=UploadistaProvider.vue-_qDn5Gvp.d.mts.map
+//# sourceMappingURL=index-DcNYDFLL.d.mts.map

package/dist/index-DcNYDFLL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DcNYDFLL.d.mts","names":[],"sources":["../src/providers/FlowManagerProvider.vue","../src/providers/UploadistaProvider.vue"],"mappings":";YAuTI,OAAA;AAAA,KACC,aAAA;EACD,OAAA,IAAW,KAAA,SAAc,OAAO;AAAA;AAAA,cAC9B,YAAA,gBAAU,eAAA,mCAAA,qBAAA,gBAAA,qBAAA,4BAAA,WAAA,EAAA,QAAA,OAAA,QAAA,4CAAA,uBAAA;AAAA,cAEV,cAAA,EAAqB,iBAAA,QAAuB,YAAA,EAAY,aAAA;AAAA,cAAW,UAAA,SAC7C,cAAY;AAAA,KACnC,iBAAA,SAAwB,CAAA;EAAA;IAE3B,MAAA,EAAQ,CAAC;EAAA;AAAA;;;KCjPN,WAAA;EACD,SAAA;EACA,SAAA;EACA,kBAAA;EACA,SAAA;EACA,eAAA;EACA,2BAAA;AAAA;AAAA,YA0EA,OAAA;AAAA,KACC,WAAA;EACD,OAAA,IAAW,KAAA,SAAc,OAAO;AAAA;AAAA,cAG9B,UAAA,gBAAU,eAAA,CAAA,WAAA,gCAAA,qBAAA,gBAAA,qBAAA,4BAAA,WAAA,EAAA,QAAA,CAAA,WAAA,IAAA,QAAA;;;;;;;cAIV,YAAA,EAAqB,eAAA,QAAuB,UAAA,EAAY,WAAA;AAAA,cAAW,QAAA,SAC7C,YAAY;AAAA,KAWnC,eAAA,SAAwB,CAAA;EAAA;IAE3B,MAAA,EAAQ,CAAC;EAAA;AAAA"}

package/dist/index.d.mts

@@ -1,8 +1,5 @@
-import { $ as FlowErrorSlotProps, A as _default$15, B as FlowInputPreviewSlotProps, C as _default$19, D as _default$17, E as UploadProps, F as _default$11, G as FlowInputProps, H as FlowInputDropZoneProps, I as FlowInputUrlFieldProps, J as FLOW_CONTEXT_KEY, K as FlowInputSlotProps, L as _default$7, M as _default$14, N as _default$12, O as _default$30, P as FlowProgressSlotProps, Q as useFlowInputContext, R as FlowInputsSlotProps, S as _default$20, T as UploadContextValue, U as FlowInputDropZoneSlotProps, V as _default$6, W as _default$5, X as FlowInputContextValue, Y as FLOW_INPUT_CONTEXT_KEY, Z as useFlowContext, _ as useUploadItemContext, a as _default$26, at as _default$10, b as UploadDropZoneProps, c as UploadItemsSlotProps, ct as FlowProps, d as UploadItemSlotProps, et as _default$3, f as _default$22, g as useUploadContext, h as UploadItemContextValue, i as _default$27, it as _default$13, j as FlowStatusSlotProps, k as _default$24, l as _default$23, lt as _default, m as UPLOAD_ITEM_CONTEXT_KEY, n as _default$29, nt as FlowDropZoneSlotProps, o as UploadProgressSlotProps, ot as _default$1, p as UPLOAD_CONTEXT_KEY, q as _default$4, r as _default$28, rt as _default$2, s as _default$25, st as FlowContextValue, t as UploadStatusSlotProps, tt as FlowDropZoneProps, u as UploadItemProps, ut as _default$16, v as UploadErrorSlotProps, w as _default$18, x as UploadDropZoneSlotProps, y as _default$21, z as _default$8 } from "./index-CxdtdMrD.mjs";
-import { A as UseFlowEventsOptions, B as InputExecutionState, C as UploadFileEventData, D as UploadValidationWarningEventData, E as UploadValidationSuccessEventData, F as DragDropState, H as useFlow, I as useDragDrop, L as FlowInputMetadata, M as isFlowEvent, N as isUploadEvent, O as UseUploadEventsOptions, P as DragDropOptions, R as FlowUploadState, S as UploadFailedEventData, T as UploadValidationFailedEventData, V as UseFlowReturn, _ as useMultiFlowUpload, a as useUploadistaClient, b as createUploadistaPlugin, c as UploadItem, d as PerformanceInsights, f as UploadInput, g as useUpload, h as UploadStatus, i as UseUploadistaClientReturn, j as useFlowEvents, k as useUploadEvents, l as useMultiUpload, m as UploadState, n as UseUploadMetricsOptions, o as MultiUploadOptions, p as UploadSessionMetrics, r as useUploadMetrics, s as MultiUploadState, t as FileUploadMetrics, u as ChunkMetrics, v as UPLOADISTA_CLIENT_KEY, w as UploadProgressEventData, x as useUploadistaEvents, y as UploadistaPluginOptions, z as FlowUploadStatus } from "./useUploadMetrics-DEdjOjLp.mjs";
-import "./composables/index.mjs";
-import "./components/index.mjs";
-import { n as _default$9, t as _default$31 } from "./UploadistaProvider.vue-_qDn5Gvp.mjs";
-import "./providers/index.mjs";
+import { $ as useFlowContext, A as _default$15, B as FlowInputsSlotProps, C as _default$19, D as _default$17, E as UploadProps, F as FlowProgressSlotProps, G as FlowInputDropZoneSlotProps, H as FlowInputPreviewSlotProps, I as _default$11, J as FlowInputSlotProps, K as _default$5, L as _default$10, M as _default$14, N as _default$13, O as _default$30, P as _default$12, Q as FlowInputContextValue, R as FlowInputUrlFieldProps, S as _default$20, T as UploadContextValue, U as _default$6, V as _default$8, W as FlowInputDropZoneProps, X as FLOW_CONTEXT_KEY, Y as _default$4, Z as FLOW_INPUT_CONTEXT_KEY, _ as useUploadItemContext, a as _default$26, at as _default$2, b as UploadDropZoneProps, c as UploadItemsSlotProps, ct as FlowProps, d as UploadItemSlotProps, et as useFlowInputContext, f as _default$22, g as useUploadContext, h as UploadItemContextValue, i as _default$27, it as FlowDropZoneSlotProps, j as FlowStatusSlotProps, k as _default$24, l as _default$23, lt as _default, m as UPLOAD_ITEM_CONTEXT_KEY, n as _default$29, nt as _default$3, o as UploadProgressSlotProps, ot as _default$1, p as UPLOAD_CONTEXT_KEY, q as FlowInputProps, r as _default$28, rt as FlowDropZoneProps, s as _default$25, st as FlowContextValue, t as UploadStatusSlotProps, tt as FlowErrorSlotProps, u as UploadItemProps, ut as _default$16, v as UploadErrorSlotProps, w as _default$18, x as UploadDropZoneSlotProps, y as _default$21, z as _default$7 } from "./index-BWeZuHjc.mjs";
+import { A as UseFlowEventsOptions, B as InputExecutionState, C as UploadFileEventData, D as UploadValidationWarningEventData, E as UploadValidationSuccessEventData, F as DragDropState, H as useFlow, I as useDragDrop, L as FlowInputMetadata, M as isFlowEvent, N as isUploadEvent, O as UseUploadEventsOptions, P as DragDropOptions, R as FlowUploadState, S as UploadFailedEventData, T as UploadValidationFailedEventData, V as UseFlowReturn, _ as useMultiFlowUpload, a as useUploadistaClient, b as createUploadistaPlugin, c as UploadItem, d as PerformanceInsights, f as UploadInput, g as useUpload, h as UploadStatus, i as UseUploadistaClientReturn, j as useFlowEvents, k as useUploadEvents, l as useMultiUpload, m as UploadState, n as UseUploadMetricsOptions, o as MultiUploadOptions, p as UploadSessionMetrics, r as useUploadMetrics, s as MultiUploadState, t as FileUploadMetrics, u as ChunkMetrics, v as UPLOADISTA_CLIENT_KEY, w as UploadProgressEventData, x as useUploadistaEvents, y as UploadistaPluginOptions, z as FlowUploadStatus } from "./index-BlM5dmy_.mjs";
+import { n as _default$9, t as _default$31 } from "./index-DcNYDFLL.mjs";
 import { calculateProgress, createFilePreview, formatDuration, formatFileSize, formatSpeed, generateUploadId, getFileExtension, isAudioFile, isBrowserFile, isDocumentFile, isImageFile, isVideoFile, revokeFilePreview, validateFileType } from "./utils/index.mjs";
-export { type ChunkMetrics, type DragDropOptions, type DragDropState, FLOW_CONTEXT_KEY, FLOW_INPUT_CONTEXT_KEY, type FileUploadMetrics, _default as Flow, _default$1 as FlowCancel, FlowContextValue, _default$2 as FlowDropZone, FlowDropZoneProps, FlowDropZoneSlotProps, _default$3 as FlowError, FlowErrorSlotProps, _default$4 as FlowInput, FlowInputContextValue, _default$5 as FlowInputDropZone, FlowInputDropZoneProps, FlowInputDropZoneSlotProps, type FlowInputMetadata, _default$6 as FlowInputPreview, FlowInputPreviewSlotProps, FlowInputProps, FlowInputSlotProps, _default$7 as FlowInputUrlField, FlowInputUrlFieldProps, _default$8 as FlowInputs, FlowInputsSlotProps, _default$9 as FlowManagerProvider, _default$10 as FlowPause, _default$11 as FlowProgress, FlowProgressSlotProps, FlowProps, _default$12 as FlowReset, _default$13 as FlowResume, _default$14 as FlowStatus, FlowStatusSlotProps, _default$15 as FlowSubmit, _default$16 as FlowUploadList, type FlowUploadState, type FlowUploadStatus, type InputExecutionState, type UploadItem as MultiUploadItem, type MultiUploadOptions, type MultiUploadState, type PerformanceInsights, UPLOADISTA_CLIENT_KEY, UPLOAD_CONTEXT_KEY, UPLOAD_ITEM_CONTEXT_KEY, _default$17 as Upload, _default$18 as UploadCancel, _default$19 as UploadClearCompleted, UploadContextValue, _default$20 as UploadDropZone, UploadDropZoneProps, UploadDropZoneSlotProps, _default$21 as UploadError, UploadErrorSlotProps, type UploadFailedEventData, type UploadFileEventData, type UploadInput, _default$22 as UploadItem, UploadItemContextValue, UploadItemProps, UploadItemSlotProps, _default$23 as UploadItems, UploadItemsSlotProps, _default$24 as UploadList, _default$25 as UploadProgress, type UploadProgressEventData, UploadProgressSlotProps, UploadProps, _default$26 as UploadReset, _default$27 as UploadRetry, type UploadSessionMetrics, _default$28 as UploadStartAll, type UploadState, _default$29 as UploadStatus, UploadStatusSlotProps, type UploadStatus as UploadStatusType, type UploadValidationFailedEventData, type UploadValidationSuccessEventData, type UploadValidationWarningEventData, _default$30 as UploadZone, type UploadistaPluginOptions, _default$31 as UploadistaProvider, type UseFlowEventsOptions, type UseFlowReturn, type UseUploadEventsOptions, type UseUploadMetricsOptions, type UseUploadistaClientReturn, calculateProgress, createFilePreview, createUploadistaPlugin, formatDuration, formatFileSize, formatSpeed, generateUploadId, getFileExtension, isAudioFile, isBrowserFile, isDocumentFile, isFlowEvent, isImageFile, isUploadEvent, isVideoFile, revokeFilePreview, useDragDrop, useFlow, useFlowContext, useFlowEvents, useFlowInputContext, useMultiFlowUpload, useMultiUpload, useUpload, useUploadContext, useUploadEvents, useUploadItemContext, useUploadMetrics, useUploadistaClient, useUploadistaEvents, validateFileType };
+export { type ChunkMetrics, type DragDropOptions, type DragDropState, FLOW_CONTEXT_KEY, FLOW_INPUT_CONTEXT_KEY, type FileUploadMetrics, _default as Flow, _default$1 as FlowCancel, type FlowContextValue, _default$2 as FlowDropZone, type FlowDropZoneProps, type FlowDropZoneSlotProps, _default$3 as FlowError, type FlowErrorSlotProps, _default$4 as FlowInput, type FlowInputContextValue, _default$5 as FlowInputDropZone, type FlowInputDropZoneProps, type FlowInputDropZoneSlotProps, type FlowInputMetadata, _default$6 as FlowInputPreview, type FlowInputPreviewSlotProps, type FlowInputProps, type FlowInputSlotProps, _default$7 as FlowInputUrlField, type FlowInputUrlFieldProps, _default$8 as FlowInputs, type FlowInputsSlotProps, _default$9 as FlowManagerProvider, _default$10 as FlowPause, _default$11 as FlowProgress, type FlowProgressSlotProps, type FlowProps, _default$12 as FlowReset, _default$13 as FlowResume, _default$14 as FlowStatus, type FlowStatusSlotProps, _default$15 as FlowSubmit, _default$16 as FlowUploadList, type FlowUploadState, type FlowUploadStatus, type InputExecutionState, type UploadItem as MultiUploadItem, type MultiUploadOptions, type MultiUploadState, type PerformanceInsights, UPLOADISTA_CLIENT_KEY, UPLOAD_CONTEXT_KEY, UPLOAD_ITEM_CONTEXT_KEY, _default$17 as Upload, _default$18 as UploadCancel, _default$19 as UploadClearCompleted, type UploadContextValue, _default$20 as UploadDropZone, type UploadDropZoneProps, type UploadDropZoneSlotProps, _default$21 as UploadError, type UploadErrorSlotProps, type UploadFailedEventData, type UploadFileEventData, type UploadInput, _default$22 as UploadItem, type UploadItemContextValue, type UploadItemProps, type UploadItemSlotProps, _default$23 as UploadItems, type UploadItemsSlotProps, _default$24 as UploadList, _default$25 as UploadProgress, type UploadProgressEventData, type UploadProgressSlotProps, type UploadProps, _default$26 as UploadReset, _default$27 as UploadRetry, type UploadSessionMetrics, _default$28 as UploadStartAll, type UploadState, _default$29 as UploadStatus, type UploadStatusSlotProps, type UploadStatus as UploadStatusType, type UploadValidationFailedEventData, type UploadValidationSuccessEventData, type UploadValidationWarningEventData, _default$30 as UploadZone, type UploadistaPluginOptions, _default$31 as UploadistaProvider, type UseFlowEventsOptions, type UseFlowReturn, type UseUploadEventsOptions, type UseUploadMetricsOptions, type UseUploadistaClientReturn, calculateProgress, createFilePreview, createUploadistaPlugin, formatDuration, formatFileSize, formatSpeed, generateUploadId, getFileExtension, isAudioFile, isBrowserFile, isDocumentFile, isFlowEvent, isImageFile, isUploadEvent, isVideoFile, revokeFilePreview, useDragDrop, useFlow, useFlowContext, useFlowEvents, useFlowInputContext, useMultiFlowUpload, useMultiUpload, useUpload, useUploadContext, useUploadEvents, useUploadItemContext, useUploadMetrics, useUploadistaClient, useUploadistaEvents, validateFileType };

package/dist/index.mjs

@@ -1 +1 @@
-import{t as e}from"./is-browser-file-CN7ymiO5.mjs";import{calculateProgress as t,createFilePreview as n,formatDuration as r,formatFileSize as i,formatSpeed as a,generateUploadId as o,getFileExtension as s,isAudioFile as c,isDocumentFile as l,isImageFile as u,isVideoFile as d,revokeFilePreview as f,validateFileType as p}from"./utils/index.mjs";import{A as m,C as h,D as g,E as _,F as v,I as y,L as b,M as x,N as S,O as C,P as w,R as T,S as E,T as D,_ as O,a as k,b as A,c as j,d as M,f as N,g as P,h as F,i as I,j as L,k as R,l as z,m as B,n as V,o as H,p as U,r as W,s as G,t as K,u as q,v as J,w as Y,x as X,y as Z}from"./upload-BJHmqKbp.mjs";import{a as Q,c as $,d as ee,i as te,l as ne,n as re,o as ie,r as ae,s as oe,t as se,u as ce}from"./useUploadMetrics-CJesoLV7.mjs";import{i as le,n as ue,t as de}from"./useUploadistaClient-C3qbTB18.mjs";import"./composables/index.mjs";import"./components/index.mjs";import{n as fe,t as pe}from"./UploadistaProvider-DU4YVCy4.mjs";import"./providers/index.mjs";export{S as FLOW_CONTEXT_KEY,w as FLOW_INPUT_CONTEXT_KEY,b as Flow,x as FlowCancel,R as FlowDropZone,C as FlowError,g as FlowInput,_ as FlowInputDropZone,D as FlowInputPreview,h as FlowInputUrlField,Y as FlowInputs,fe as FlowManagerProvider,L as FlowPause,E as FlowProgress,X as FlowReset,m as FlowResume,A as FlowStatus,Z as FlowSubmit,T as FlowUploadList,ue as UPLOADISTA_CLIENT_KEY,U as UPLOAD_CONTEXT_KEY,B as UPLOAD_ITEM_CONTEXT_KEY,N as Upload,M as UploadCancel,q as UploadClearCompleted,z as UploadDropZone,j as UploadError,G as UploadItem,H as UploadItems,J as UploadList,k as UploadProgress,I as UploadReset,W as UploadRetry,V as UploadStartAll,K as UploadStatus,O as UploadZone,pe as UploadistaProvider,t as calculateProgress,n as createFilePreview,le as createUploadistaPlugin,r as formatDuration,i as formatFileSize,a as formatSpeed,o as generateUploadId,s as getFileExtension,c as isAudioFile,e as isBrowserFile,l as isDocumentFile,$ as isFlowEvent,u as isImageFile,ne as isUploadEvent,d as isVideoFile,f as revokeFilePreview,ce as useDragDrop,ee as useFlow,v as useFlowContext,oe as useFlowEvents,y as useFlowInputContext,te as useMultiFlowUpload,ae as useMultiUpload,re as useUpload,F as useUploadContext,ie as useUploadEvents,P as useUploadItemContext,se as useUploadMetrics,de as useUploadistaClient,Q as useUploadistaEvents,p as validateFileType};
+import{calculateProgress as e,createFilePreview as t,formatDuration as n,formatFileSize as r,formatSpeed as i,generateUploadId as a,getFileExtension as o,isAudioFile as s,isBrowserFile as c,isDocumentFile as l,isImageFile as u,isVideoFile as d,revokeFilePreview as f,validateFileType as p}from"./utils/index.mjs";import{A as m,C as h,D as g,E as _,F as v,I as y,L as b,M as x,N as S,O as C,P as w,R as T,S as E,T as D,_ as O,a as k,b as A,c as j,d as M,f as N,g as P,h as F,i as I,j as L,k as R,l as z,m as B,n as V,o as H,p as U,r as W,s as G,t as K,u as q,v as J,w as Y,x as X,y as Z}from"./components-BMfV_7cn.mjs";import{a as Q,c as $,d as ee,i as te,l as ne,n as re,o as ie,r as ae,s as oe,t as se,u as ce}from"./composables-CH4pv7yG.mjs";import{i as le,n as ue,t as de}from"./useUploadistaClient-CgabcTy6.mjs";import{n as fe,t as pe}from"./providers-Dhq5W5tR.mjs";export{S as FLOW_CONTEXT_KEY,w as FLOW_INPUT_CONTEXT_KEY,b as Flow,x as FlowCancel,L as FlowDropZone,m as FlowError,R as FlowInput,C as FlowInputDropZone,g as FlowInputPreview,D as FlowInputUrlField,_ as FlowInputs,fe as FlowManagerProvider,Y as FlowPause,h as FlowProgress,E as FlowReset,X as FlowResume,A as FlowStatus,Z as FlowSubmit,T as FlowUploadList,ue as UPLOADISTA_CLIENT_KEY,U as UPLOAD_CONTEXT_KEY,B as UPLOAD_ITEM_CONTEXT_KEY,N as Upload,M as UploadCancel,q as UploadClearCompleted,z as UploadDropZone,j as UploadError,G as UploadItem,H as UploadItems,J as UploadList,k as UploadProgress,I as UploadReset,W as UploadRetry,V as UploadStartAll,K as UploadStatus,O as UploadZone,pe as UploadistaProvider,e as calculateProgress,t as createFilePreview,le as createUploadistaPlugin,n as formatDuration,r as formatFileSize,i as formatSpeed,a as generateUploadId,o as getFileExtension,s as isAudioFile,c as isBrowserFile,l as isDocumentFile,$ as isFlowEvent,u as isImageFile,ne as isUploadEvent,d as isVideoFile,f as revokeFilePreview,ce as useDragDrop,ee as useFlow,v as useFlowContext,oe as useFlowEvents,y as useFlowInputContext,te as useMultiFlowUpload,ae as useMultiUpload,re as useUpload,F as useUploadContext,ie as useUploadEvents,P as useUploadItemContext,se as useUploadMetrics,de as useUploadistaClient,Q as useUploadistaEvents,p as validateFileType};

package/dist/providers/index.d.mts

@@ -1,2 +1,2 @@
-import { n as _default, t as _default$1 } from "../UploadistaProvider.vue-_qDn5Gvp.mjs";
+import { n as _default, t as _default$1 } from "../index-DcNYDFLL.mjs";
 export { _default as FlowManagerProvider, _default$1 as UploadistaProvider };

package/dist/providers/index.mjs

@@ -1 +1 @@
-import"../useUploadistaClient-C3qbTB18.mjs";import{n as e,t}from"../UploadistaProvider-DU4YVCy4.mjs";export{e as FlowManagerProvider,t as UploadistaProvider};
+import{n as e,t}from"../providers-Dhq5W5tR.mjs";export{e as FlowManagerProvider,t as UploadistaProvider};

package/dist/{UploadistaProvider-DU4YVCy4.mjs → providers-Dhq5W5tR.mjs}

@@ -1,2 +1,2 @@
-import{n as e,r as t,t as n}from"./useUploadistaClient-C3qbTB18.mjs";import{createBlock as r,defineComponent as i,onBeforeUnmount as a,onMounted as o,openBlock as s,provide as c,ref as l,renderSlot as u,withCtx as d}from"vue";import{createUploadistaClient as f}from"@uploadista/client-browser";import{EventType as p}from"@uploadista/core/flow";import{UploadEventType as m}from"@uploadista/core/types";import{FlowManager as h}from"@uploadista/client-core";const g=i({__name:`FlowManagerProvider`,setup(e){function t(e){let t=e;return t.eventType===p.FlowStart||t.eventType===p.FlowEnd||t.eventType===p.FlowError||t.eventType===p.NodeStart||t.eventType===p.NodeEnd||t.eventType===p.NodePause||t.eventType===p.NodeResume||t.eventType===p.NodeError}let{client:r,subscribeToEvents:i}=n(),s=new Map,l=null;return o(()=>{l=i(e=>{if(t(e)){for(let t of s.values())t.manager.handleFlowEvent(e);return}if(`type`in e&&e.type===m.UPLOAD_PROGRESS&&`data`in e){let t=e;for(let e of s.values())e.manager.handleUploadProgress(t.data.id,t.data.progress,t.data.total)}})}),a(()=>{l?.();for(let e of s.values())e.manager.cleanup();s.clear()}),c(`flowManagerContext`,{getManager:(e,t,n)=>{let i=s.get(e);if(i)return i.refCount++,i.manager;let a=new h(r.uploadWithFlow,t,n,r.multiInputFlowUpload);return s.set(e,{manager:a,refCount:1,flowId:e}),a},releaseManager:e=>{let t=s.get(e);t&&(t.refCount--,t.refCount<=0&&(t.manager.cleanup(),s.delete(e)))}}),(e,t)=>u(e.$slots,`default`)}}),_=i({__name:`UploadistaProvider`,props:{serverUrl:{},storageId:{default:`local`},uploadistaBasePath:{default:`uploadista`},chunkSize:{default:1024*1024},parallelUploads:{default:1},storeFingerprintForResuming:{type:Boolean,default:!0}},setup(n){let i=n,o=l(new Set),p=f({baseUrl:i.serverUrl,storageId:i.storageId,uploadistaBasePath:i.uploadistaBasePath,chunkSize:i.chunkSize,parallelUploads:i.parallelUploads,storeFingerprintForResuming:i.storeFingerprintForResuming,onEvent:e=>{o.value.forEach(t=>{try{t(e)}catch(e){console.error(`Error in event subscriber:`,e)}})}});return c(e,p),c(t,o),a(()=>{p.closeAllWebSockets()}),(e,t)=>(s(),r(g,null,{default:d(()=>[u(e.$slots,`default`)]),_:3}))}});export{g as n,_ as t};
-//# sourceMappingURL=UploadistaProvider-DU4YVCy4.mjs.map
+import{n as e,r as t,t as n}from"./useUploadistaClient-CgabcTy6.mjs";import{createBlock as r,defineComponent as i,onBeforeUnmount as a,onMounted as o,openBlock as s,provide as c,ref as l,renderSlot as u,withCtx as d}from"vue";import{createUploadistaClient as f}from"@uploadista/client-browser";import{EventType as p}from"@uploadista/core/flow";import{UploadEventType as m}from"@uploadista/core/types";import{FlowManager as h}from"@uploadista/client-core";const g=i({__name:`FlowManagerProvider`,setup(e){function t(e){let t=e;return t.eventType===p.FlowStart||t.eventType===p.FlowEnd||t.eventType===p.FlowError||t.eventType===p.NodeStart||t.eventType===p.NodeEnd||t.eventType===p.NodePause||t.eventType===p.NodeResume||t.eventType===p.NodeError}let{client:r,subscribeToEvents:i}=n(),s=new Map,l=null;return o(()=>{l=i(e=>{if(t(e)){for(let t of s.values())t.manager.handleFlowEvent(e);return}if(`type`in e&&e.type===m.UPLOAD_PROGRESS&&`data`in e){let t=e;for(let e of s.values())e.manager.handleUploadProgress(t.data.id,t.data.progress,t.data.total)}})}),a(()=>{l?.();for(let e of s.values())e.manager.cleanup();s.clear()}),c(`flowManagerContext`,{getManager:(e,t,n)=>{let i=s.get(e);if(i)return i.refCount++,i.manager;let a=new h(r.uploadWithFlow,t,n,r.multiInputFlowUpload);return s.set(e,{manager:a,refCount:1,flowId:e}),a},releaseManager:e=>{let t=s.get(e);t&&(t.refCount--,t.refCount<=0&&(t.manager.cleanup(),s.delete(e)))}}),(e,t)=>u(e.$slots,`default`)}}),_=i({__name:`UploadistaProvider`,props:{serverUrl:{},storageId:{default:`local`},uploadistaBasePath:{default:`uploadista`},chunkSize:{default:1024*1024},parallelUploads:{default:1},storeFingerprintForResuming:{type:Boolean,default:!0}},setup(n){let i=n,o=l(new Set),p=f({baseUrl:i.serverUrl,storageId:i.storageId,uploadistaBasePath:i.uploadistaBasePath,chunkSize:i.chunkSize,parallelUploads:i.parallelUploads,storeFingerprintForResuming:i.storeFingerprintForResuming,onEvent:e=>{o.value.forEach(t=>{try{t(e)}catch(e){console.error(`Error in event subscriber:`,e)}})}});return c(e,p),c(t,o),a(()=>{p.closeAllWebSockets()}),(e,t)=>(s(),r(g,null,{default:d(()=>[u(e.$slots,`default`)]),_:3}))}});export{g as n,_ as t};
+//# sourceMappingURL=providers-Dhq5W5tR.mjs.map

package/dist/providers-Dhq5W5tR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers-Dhq5W5tR.mjs","names":[],"sources":["../src/providers/FlowManagerProvider.vue","../src/providers/UploadistaProvider.vue"],"sourcesContent":["<template>\n  <slot />\n</template>\n\n<script setup lang=\"ts\">\nimport type {\n  BrowserUploadInput,\n  UploadistaEvent,\n} from \"@uploadista/client-browser\";\nimport {\n  FlowManager,\n  type FlowManagerCallbacks,\n  type FlowUploadOptions,\n} from \"@uploadista/client-core\";\nimport { EventType, type FlowEvent } from \"@uploadista/core/flow\";\nimport { UploadEventType } from \"@uploadista/core/types\";\nimport { onBeforeUnmount, onMounted, provide } from \"vue\";\nimport { useUploadistaClient } from \"../composables/useUploadistaClient\";\n\n/**\n * Type guard to check if an event is a flow event\n */\nfunction isFlowEvent(event: UploadistaEvent): event is FlowEvent {\n  const flowEvent = event as FlowEvent;\n  return (\n    flowEvent.eventType === EventType.FlowStart ||\n    flowEvent.eventType === EventType.FlowEnd ||\n    flowEvent.eventType === EventType.FlowError ||\n    flowEvent.eventType === EventType.NodeStart ||\n    flowEvent.eventType === EventType.NodeEnd ||\n    flowEvent.eventType === EventType.NodePause ||\n    flowEvent.eventType === EventType.NodeResume ||\n    flowEvent.eventType === EventType.NodeError\n  );\n}\n\n/**\n * Internal manager registry entry with ref counting\n */\ninterface ManagerEntry {\n  manager: FlowManager<unknown>;\n  refCount: number;\n  flowId: string;\n}\n\n/**\n * Context value providing access to flow managers\n */\ninterface FlowManagerContextValue {\n  getManager: (\n    flowId: string,\n    callbacks: FlowManagerCallbacks,\n    options: FlowUploadOptions,\n  ) => FlowManager<unknown>;\n  releaseManager: (flowId: string) => void;\n}\n\nconst { client, subscribeToEvents } = useUploadistaClient();\nconst managers = new Map<string, ManagerEntry>();\nlet unsubscribe: (() => void) | null = null;\n\n// Subscribe to events and route to managers\nonMounted(() => {\n  unsubscribe = subscribeToEvents((event: UploadistaEvent) => {\n    // Route flow events to all managers (they filter by jobId internally)\n    if (isFlowEvent(event)) {\n      for (const entry of managers.values()) {\n        entry.manager.handleFlowEvent(event);\n      }\n      return;\n    }\n\n    // Route upload progress events to all managers\n    if (\n      \"type\" in event &&\n      event.type === UploadEventType.UPLOAD_PROGRESS &&\n      \"data\" in event\n    ) {\n      const uploadEvent = event;\n\n      for (const entry of managers.values()) {\n        entry.manager.handleUploadProgress(\n          uploadEvent.data.id,\n          uploadEvent.data.progress,\n          uploadEvent.data.total,\n        );\n      }\n    }\n  });\n});\n\n// Cleanup on unmount\nonBeforeUnmount(() => {\n  unsubscribe?.();\n  for (const entry of managers.values()) {\n    entry.manager.cleanup();\n  }\n  managers.clear();\n});\n\nconst getManager = (\n  flowId: string,\n  callbacks: FlowManagerCallbacks,\n  options: FlowUploadOptions,\n): FlowManager<unknown> => {\n  const existing = managers.get(flowId);\n\n  if (existing) {\n    // Increment ref count for existing manager\n    existing.refCount++;\n    return existing.manager;\n  }\n\n  // Create new manager\n  const manager = new FlowManager<BrowserUploadInput>(\n    client.uploadWithFlow,\n    callbacks,\n    options,\n    client.multiInputFlowUpload,\n  );\n\n  managers.set(flowId, {\n    manager,\n    refCount: 1,\n    flowId,\n  });\n\n  return manager;\n};\n\nconst releaseManager = (flowId: string) => {\n  const existing = managers.get(flowId);\n  if (!existing) return;\n\n  existing.refCount--;\n\n  // Clean up when no more refs\n  if (existing.refCount <= 0) {\n    existing.manager.cleanup();\n    managers.delete(flowId);\n  }\n};\n\n// Provide the context\nconst flowManagerContext: FlowManagerContextValue = {\n  getManager,\n  releaseManager,\n};\n\nprovide(\"flowManagerContext\", flowManagerContext);\n</script>\n","<script setup lang=\"ts\">\nimport {\n  createUploadistaClient,\n  type UploadistaEvent,\n} from \"@uploadista/client-browser\";\nimport { onBeforeUnmount, provide, ref } from \"vue\";\nimport {\n  UPLOADISTA_CLIENT_KEY,\n  UPLOADISTA_EVENT_SUBSCRIBERS_KEY,\n} from \"../composables/plugin\";\nimport FlowManagerProvider from \"./FlowManagerProvider.vue\";\n\nconst props = withDefaults(\n  defineProps<{\n    serverUrl: string;\n    storageId?: string;\n    uploadistaBasePath?: string;\n    chunkSize?: number;\n    parallelUploads?: number;\n    storeFingerprintForResuming?: boolean;\n  }>(),\n  {\n    storageId: \"local\",\n    uploadistaBasePath: \"uploadista\",\n    chunkSize: 1024 * 1024,\n    parallelUploads: 1,\n    storeFingerprintForResuming: true,\n  },\n);\n\n// Create a shared set of event subscribers\nconst eventSubscribers = ref(new Set<(event: UploadistaEvent) => void>());\n\nconst client = createUploadistaClient({\n  baseUrl: props.serverUrl,\n  storageId: props.storageId,\n  uploadistaBasePath: props.uploadistaBasePath,\n  chunkSize: props.chunkSize,\n  parallelUploads: props.parallelUploads,\n  storeFingerprintForResuming: props.storeFingerprintForResuming,\n  onEvent: (event) => {\n    // Dispatch to all subscribers registered via subscribeToEvents\n    eventSubscribers.value.forEach((subscriber) => {\n      try {\n        subscriber(event);\n      } catch (err) {\n        console.error(\"Error in event subscriber:\", err);\n      }\n    });\n  },\n});\n\nprovide(UPLOADISTA_CLIENT_KEY, client);\nprovide(UPLOADISTA_EVENT_SUBSCRIBERS_KEY, eventSubscribers);\n\nonBeforeUnmount(() => {\n  client.closeAllWebSockets();\n});\n</script>\n\n<template>\n  <FlowManagerProvider>\n    <slot />\n  </FlowManagerProvider>\n</template>\n"],"mappings":"wfAsBA,SAAS,EAAY,EAA4C,CAC/D,IAAM,EAAY,EAClB,OACE,EAAU,YAAc,EAAU,WAClC,EAAU,YAAc,EAAU,SAClC,EAAU,YAAc,EAAU,WAClC,EAAU,YAAc,EAAU,WAClC,EAAU,YAAc,EAAU,SAClC,EAAU,YAAc,EAAU,WAClC,EAAU,YAAc,EAAU,YAClC,EAAU,YAAc,EAAU,SAEtC,CAuBA,GAAM,CAAE,SAAQ,qBAAsB,EAAoB,EACpD,EAAW,IAAI,IACjB,EAAmC,YAGvC,MAAgB,CACd,EAAc,EAAmB,GAA2B,CAE1D,GAAI,EAAY,CAAK,EAAG,CACtB,IAAK,IAAM,KAAS,EAAS,OAAO,EAClC,EAAM,QAAQ,gBAAgB,CAAK,EAErC,MACF,CAGA,GACE,SAAU,GACV,EAAM,OAAS,EAAgB,iBAC/B,SAAU,EACV,CACA,IAAM,EAAc,EAEpB,IAAK,IAAM,KAAS,EAAS,OAAO,EAClC,EAAM,QAAQ,qBACZ,EAAY,KAAK,GACjB,EAAY,KAAK,SACjB,EAAY,KAAK,KACnB,CAEJ,CACF,CAAC,CACH,CAAC,EAGD,MAAsB,CACpB,IAAc,EACd,IAAK,IAAM,KAAS,EAAS,OAAO,EAClC,EAAM,QAAQ,QAAQ,EAExB,EAAS,MAAM,CACjB,CAAC,EAmDD,EAAQ,qBAAsB,CAJ5B,YA5CA,EACA,EACA,IACyB,CACzB,IAAM,EAAW,EAAS,IAAI,CAAM,EAEpC,GAAI,EAGF,MADA,GAAS,WACF,EAAS,QAIlB,IAAM,EAAU,IAAI,EAClB,EAAO,eACP,EACA,EACA,EAAO,oBACT,EAQA,OANA,EAAS,IAAI,EAAQ,CACnB,UACA,SAAU,EACV,QACF,CAAC,EAEM,CACT,EAkBE,eAhBsB,GAAmB,CACzC,IAAM,EAAW,EAAS,IAAI,CAAM,EAC/B,IAEL,EAAS,WAGL,EAAS,UAAY,IACvB,EAAS,QAAQ,QAAQ,EACzB,EAAS,OAAO,CAAM,GAE1B,CAQ8B,CAAkB,SApJ9C,EAAQ,EAAA,OAAA,SAAA,0PCWV,IAAM,EAAQ,EAmBR,EAAmB,EAAI,IAAI,GAAuC,EAElE,EAAS,EAAuB,CACpC,QAAS,EAAM,UACf,UAAW,EAAM,UACjB,mBAAoB,EAAM,mBAC1B,UAAW,EAAM,UACjB,gBAAiB,EAAM,gBACvB,4BAA6B,EAAM,4BACnC,QAAU,GAAU,CAElB,EAAiB,MAAM,QAAS,GAAe,CAC7C,GAAI,CACF,EAAW,CAAK,CAClB,OAAS,EAAK,CACZ,QAAQ,MAAM,6BAA8B,CAAG,CACjD,CACF,CAAC,CACH,CACF,CAAC,SAED,EAAQ,EAAuB,CAAM,EACrC,EAAQ,EAAkC,CAAgB,EAE1D,MAAsB,CACpB,EAAO,mBAAmB,CAC5B,CAAC,cAIC,EAEsB,EAAA,KAAA,eADZ,CAAR,EAAQ,EAAA,OAAA,SAAA,CAAA,CAAA"}

package/dist/{upload-y0K2veej.css → style.css}

@@ -83,7 +83,6 @@
   border-radius: 0.25rem;
 }
 
-
 .upload-list[data-v-270204db] {
   display: flex;
   flex-direction: column;
@@ -153,7 +152,6 @@
   border-radius: 0.25rem;
 }
 
-
 .upload-zone[data-v-c73032fa] {
   cursor: pointer;
   user-select: none;
@@ -176,6 +174,3 @@
 .upload-zone__errors p[data-v-c73032fa] {
   margin: 0.25rem 0;
 }
-
-
-/*# sourceMappingURL=upload-y0K2veej.css.map*/

package/dist/{useUploadistaClient-C3qbTB18.mjs → useUploadistaClient-CgabcTy6.mjs}

@@ -1,2 +1,2 @@
 import{inject as e,ref as t}from"vue";import{createUploadistaClient as n}from"@uploadista/client-browser";const r=Symbol(`uploadista-client`),i=Symbol(`uploadista-event-subscribers`);function a(e){return{install(a){let o=t(new Set),s=n({...e,onEvent:t=>{o.value.forEach(e=>{e(t)}),e.onEvent?.(t)}});a.provide(r,s),a.provide(i,o)}}}function o(){let t=e(r);if(!t)throw Error(`useUploadistaClient must be used within a component tree that has the Uploadista plugin or provider installed. Make sure to either use app.use(createUploadistaPlugin({ ... })) in your main app file, or wrap your component tree with <UploadistaProvider>.`);let n=e(i);return{client:t,subscribeToEvents:e=>n?(n.value.add(e),()=>{n.value.delete(e)}):(console.warn(`subscribeToEvents called but no event subscribers provided. Events will not be dispatched. Make sure to use UploadistaProvider or createUploadistaPlugin with proper configuration.`),()=>{})}}export{a as i,r as n,i as r,o as t};
-//# sourceMappingURL=useUploadistaClient-C3qbTB18.mjs.map
+//# sourceMappingURL=useUploadistaClient-CgabcTy6.mjs.map

package/dist/{useUploadistaClient-C3qbTB18.mjs.map → useUploadistaClient-CgabcTy6.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"useUploadistaClient-C3qbTB18.mjs","names":[],"sources":["../src/composables/plugin.ts","../src/composables/useUploadistaClient.ts"],"sourcesContent":["import {\n  createUploadistaClient,\n  type UploadistaClientOptions,\n  type UploadistaEvent,\n} from \"@uploadista/client-browser\";\nimport type { App, InjectionKey, Ref } from \"vue\";\nimport { ref } from \"vue\";\n\nexport interface UploadistaPluginOptions extends UploadistaClientOptions {\n  /**\n   * Global event handler for all upload and flow events from this client\n   */\n  onEvent?: UploadistaClientOptions[\"onEvent\"];\n}\n\nexport const UPLOADISTA_CLIENT_KEY: InjectionKey<\n  ReturnType<typeof createUploadistaClient>\n> = Symbol(\"uploadista-client\");\n\nexport const UPLOADISTA_EVENT_SUBSCRIBERS_KEY: InjectionKey<\n  Ref<Set<(event: UploadistaEvent) => void>>\n> = Symbol(\"uploadista-event-subscribers\");\n\n/**\n * Vue plugin for providing Uploadista client instance globally.\n * Uses Vue's provide/inject pattern to make the client available\n * throughout the component tree.\n *\n * @param options - Uploadista client configuration options\n * @returns Vue plugin object\n *\n * @example\n * ```typescript\n * import { createApp } from 'vue';\n * import { createUploadistaPlugin } from '@uploadista/vue';\n * import App from './App.vue';\n *\n * const app = createApp(App);\n *\n * app.use(createUploadistaPlugin({\n *   baseUrl: 'https://api.example.com',\n *   storageId: 'my-storage',\n *   chunkSize: 1024 * 1024, // 1MB\n *   storeFingerprintForResuming: true,\n *   onEvent: (event) => {\n *     console.log('Upload event:', event);\n *   }\n * }));\n *\n * app.mount('#app');\n * ```\n */\nexport function createUploadistaPlugin(options: UploadistaPluginOptions) {\n  return {\n    install(app: App) {\n      // Create a shared set of event subscribers\n      const eventSubscribers = ref(new Set<(event: UploadistaEvent) => void>());\n\n      const client = createUploadistaClient({\n        ...options,\n        onEvent: (event) => {\n          // Dispatch to all subscribers registered via subscribeToEvents\n          eventSubscribers.value.forEach((subscriber) => {\n            subscriber(event);\n          });\n\n          // Call the original onEvent handler if provided\n          options.onEvent?.(event);\n        },\n      });\n\n      app.provide(UPLOADISTA_CLIENT_KEY, client);\n      app.provide(UPLOADISTA_EVENT_SUBSCRIBERS_KEY, eventSubscribers);\n    },\n  };\n}\n","import type { UploadistaEvent } from \"@uploadista/client-browser\";\nimport { inject, type Ref } from \"vue\";\nimport {\n  UPLOADISTA_CLIENT_KEY,\n  UPLOADISTA_EVENT_SUBSCRIBERS_KEY,\n} from \"./plugin\";\n\n/**\n * Access the Uploadista client instance from the plugin or provider.\n * Must be used within a component tree that has the Uploadista plugin or provider installed.\n *\n * @returns Uploadista client instance with event subscription\n * @throws Error if used outside of Uploadista plugin/provider context\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useUploadistaClient } from '@uploadista/vue';\n *\n * const { client, subscribeToEvents } = useUploadistaClient();\n *\n * // Subscribe to all events\n * const unsubscribe = subscribeToEvents((event) => {\n *   console.log('Upload event:', event);\n * });\n *\n * // Clean up on unmount\n * onUnmounted(() => {\n *   unsubscribe();\n * });\n * </script>\n * ```\n */\nexport function useUploadistaClient() {\n  const client = inject(UPLOADISTA_CLIENT_KEY);\n\n  if (!client) {\n    throw new Error(\n      \"useUploadistaClient must be used within a component tree that has the Uploadista plugin or provider installed. \" +\n        \"Make sure to either use app.use(createUploadistaPlugin({ ... })) in your main app file, \" +\n        \"or wrap your component tree with <UploadistaProvider>.\",\n    );\n  }\n\n  // Try to get the shared event subscribers from the provider\n  const eventSubscribersRef = inject<\n    Ref<Set<(event: UploadistaEvent) => void>> | undefined\n  >(UPLOADISTA_EVENT_SUBSCRIBERS_KEY);\n\n  const subscribeToEvents = (handler: (event: UploadistaEvent) => void) => {\n    if (!eventSubscribersRef) {\n      console.warn(\n        \"subscribeToEvents called but no event subscribers provided. Events will not be dispatched. \" +\n          \"Make sure to use UploadistaProvider or createUploadistaPlugin with proper configuration.\",\n      );\n      return () => {\n        // No-op unsubscribe if subscribers aren't available\n      };\n    }\n\n    eventSubscribersRef.value.add(handler);\n    return () => {\n      eventSubscribersRef.value.delete(handler);\n    };\n  };\n\n  return {\n    client,\n    subscribeToEvents,\n  };\n}\n\nexport type UseUploadistaClientReturn = ReturnType<typeof useUploadistaClient>;\n"],"mappings":"0GAeA,MAAa,EAET,OAAO,oBAAoB,CAElB,EAET,OAAO,+BAA+B,CA+B1C,SAAgB,EAAuB,EAAkC,CACvE,MAAO,CACL,QAAQ,EAAU,CAEhB,IAAM,EAAmB,EAAI,IAAI,IAAwC,CAEnE,EAAS,EAAuB,CACpC,GAAG,EACH,QAAU,GAAU,CAElB,EAAiB,MAAM,QAAS,GAAe,CAC7C,EAAW,EAAM,EACjB,CAGF,EAAQ,UAAU,EAAM,EAE3B,CAAC,CAEF,EAAI,QAAQ,EAAuB,EAAO,CAC1C,EAAI,QAAQ,EAAkC,EAAiB,EAElE,CCzCH,SAAgB,GAAsB,CACpC,IAAM,EAAS,EAAO,EAAsB,CAE5C,GAAI,CAAC,EACH,MAAU,MACR,gQAGD,CAIH,IAAM,EAAsB,EAE1B,EAAiC,CAmBnC,MAAO,CACL,SACA,kBAnByB,GACpB,GAUL,EAAoB,MAAM,IAAI,EAAQ,KACzB,CACX,EAAoB,MAAM,OAAO,EAAQ,IAXzC,QAAQ,KACN,sLAED,KACY,IAchB"}
+{"version":3,"file":"useUploadistaClient-CgabcTy6.mjs","names":[],"sources":["../src/composables/plugin.ts","../src/composables/useUploadistaClient.ts"],"sourcesContent":["import {\n  createUploadistaClient,\n  type UploadistaClientOptions,\n  type UploadistaEvent,\n} from \"@uploadista/client-browser\";\nimport type { App, InjectionKey, Ref } from \"vue\";\nimport { ref } from \"vue\";\n\nexport interface UploadistaPluginOptions extends UploadistaClientOptions {\n  /**\n   * Global event handler for all upload and flow events from this client\n   */\n  onEvent?: UploadistaClientOptions[\"onEvent\"];\n}\n\nexport const UPLOADISTA_CLIENT_KEY: InjectionKey<\n  ReturnType<typeof createUploadistaClient>\n> = Symbol(\"uploadista-client\");\n\nexport const UPLOADISTA_EVENT_SUBSCRIBERS_KEY: InjectionKey<\n  Ref<Set<(event: UploadistaEvent) => void>>\n> = Symbol(\"uploadista-event-subscribers\");\n\n/**\n * Vue plugin for providing Uploadista client instance globally.\n * Uses Vue's provide/inject pattern to make the client available\n * throughout the component tree.\n *\n * @param options - Uploadista client configuration options\n * @returns Vue plugin object\n *\n * @example\n * ```typescript\n * import { createApp } from 'vue';\n * import { createUploadistaPlugin } from '@uploadista/vue';\n * import App from './App.vue';\n *\n * const app = createApp(App);\n *\n * app.use(createUploadistaPlugin({\n *   baseUrl: 'https://api.example.com',\n *   storageId: 'my-storage',\n *   chunkSize: 1024 * 1024, // 1MB\n *   storeFingerprintForResuming: true,\n *   onEvent: (event) => {\n *     console.log('Upload event:', event);\n *   }\n * }));\n *\n * app.mount('#app');\n * ```\n */\nexport function createUploadistaPlugin(options: UploadistaPluginOptions) {\n  return {\n    install(app: App) {\n      // Create a shared set of event subscribers\n      const eventSubscribers = ref(new Set<(event: UploadistaEvent) => void>());\n\n      const client = createUploadistaClient({\n        ...options,\n        onEvent: (event) => {\n          // Dispatch to all subscribers registered via subscribeToEvents\n          eventSubscribers.value.forEach((subscriber) => {\n            subscriber(event);\n          });\n\n          // Call the original onEvent handler if provided\n          options.onEvent?.(event);\n        },\n      });\n\n      app.provide(UPLOADISTA_CLIENT_KEY, client);\n      app.provide(UPLOADISTA_EVENT_SUBSCRIBERS_KEY, eventSubscribers);\n    },\n  };\n}\n","import type { UploadistaEvent } from \"@uploadista/client-browser\";\nimport { inject, type Ref } from \"vue\";\nimport {\n  UPLOADISTA_CLIENT_KEY,\n  UPLOADISTA_EVENT_SUBSCRIBERS_KEY,\n} from \"./plugin\";\n\n/**\n * Access the Uploadista client instance from the plugin or provider.\n * Must be used within a component tree that has the Uploadista plugin or provider installed.\n *\n * @returns Uploadista client instance with event subscription\n * @throws Error if used outside of Uploadista plugin/provider context\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useUploadistaClient } from '@uploadista/vue';\n *\n * const { client, subscribeToEvents } = useUploadistaClient();\n *\n * // Subscribe to all events\n * const unsubscribe = subscribeToEvents((event) => {\n *   console.log('Upload event:', event);\n * });\n *\n * // Clean up on unmount\n * onUnmounted(() => {\n *   unsubscribe();\n * });\n * </script>\n * ```\n */\nexport function useUploadistaClient() {\n  const client = inject(UPLOADISTA_CLIENT_KEY);\n\n  if (!client) {\n    throw new Error(\n      \"useUploadistaClient must be used within a component tree that has the Uploadista plugin or provider installed. \" +\n        \"Make sure to either use app.use(createUploadistaPlugin({ ... })) in your main app file, \" +\n        \"or wrap your component tree with <UploadistaProvider>.\",\n    );\n  }\n\n  // Try to get the shared event subscribers from the provider\n  const eventSubscribersRef = inject<\n    Ref<Set<(event: UploadistaEvent) => void>> | undefined\n  >(UPLOADISTA_EVENT_SUBSCRIBERS_KEY);\n\n  const subscribeToEvents = (handler: (event: UploadistaEvent) => void) => {\n    if (!eventSubscribersRef) {\n      console.warn(\n        \"subscribeToEvents called but no event subscribers provided. Events will not be dispatched. \" +\n          \"Make sure to use UploadistaProvider or createUploadistaPlugin with proper configuration.\",\n      );\n      return () => {\n        // No-op unsubscribe if subscribers aren't available\n      };\n    }\n\n    eventSubscribersRef.value.add(handler);\n    return () => {\n      eventSubscribersRef.value.delete(handler);\n    };\n  };\n\n  return {\n    client,\n    subscribeToEvents,\n  };\n}\n\nexport type UseUploadistaClientReturn = ReturnType<typeof useUploadistaClient>;\n"],"mappings":"0GAeA,MAAa,EAET,OAAO,mBAAmB,EAEjB,EAET,OAAO,8BAA8B,EA+BzC,SAAgB,EAAuB,EAAkC,CACvE,MAAO,CACL,QAAQ,EAAU,CAEhB,IAAM,EAAmB,EAAI,IAAI,GAAuC,EAElE,EAAS,EAAuB,CACpC,GAAG,EACH,QAAU,GAAU,CAElB,EAAiB,MAAM,QAAS,GAAe,CAC7C,EAAW,CAAK,CAClB,CAAC,EAGD,EAAQ,UAAU,CAAK,CACzB,CACF,CAAC,EAED,EAAI,QAAQ,EAAuB,CAAM,EACzC,EAAI,QAAQ,EAAkC,CAAgB,CAChE,CACF,CACF,CC1CA,SAAgB,GAAsB,CACpC,IAAM,EAAS,EAAO,CAAqB,EAE3C,GAAI,CAAC,EACH,MAAU,MACR,+PAGF,EAIF,IAAM,EAAsB,EAE1B,CAAgC,EAmBlC,MAAO,CACL,SACA,kBAnByB,GACpB,GAUL,EAAoB,MAAM,IAAI,CAAO,MACxB,CACX,EAAoB,MAAM,OAAO,CAAO,CAC1C,IAZE,QAAQ,KACN,qLAEF,MACa,CAEb,EAYJ,CACF"}

package/dist/utils/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/utils/is-browser-file.ts","../../src/utils/index.ts"],"mappings":";cAAa,aAAA,GAAiB,KAAA,cAAiB,KAAA,IAAS,IAAA;;;;AAAxD;;;;;iBCOgB,cAAA,CAAe,KAAA;;;;iBAWf,WAAA,CAAY,cAAA;;;AAX5B;iBAsBgB,cAAA,CAAe,YAAA;;;;iBAuBf,gBAAA,CAAiB,IAAA,EAAM,IAAA,EAAM,MAAA;;;;iBAsB7B,gBAAA,CAAA;AA7ChB;;;AAAA,iBAoDgB,gBAAA,CAAiB,QAAA;;AA7BjC;;iBAqCgB,WAAA,CAAY,IAAA,EAAM,IAAA;;;;iBAOlB,WAAA,CAAY,IAAA,EAAM,IAAA;;;AAtBlC;iBA6BgB,WAAA,CAAY,IAAA,EAAM,IAAA;;;;iBAOlB,cAAA,CAAe,IAAA,EAAM,IAAA;;;;iBAoBrB,iBAAA,CAAkB,IAAA,EAAM,IAAA;AAzCxC;;;AAAA,iBAmDgB,iBAAA,CAAkB,UAAA;;AA5ClC;;iBAmDgB,iBAAA,CAAkB,OAAA,UAAiB,KAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/utils/is-browser-file.ts","../../src/utils/index.ts"],"mappings":";cAAa,aAAA,GAAiB,KAAA,cAAiB,KAAA,IAAS,IACF;;;;AADtD;;;;;iBCOgB,cAAA,CAAe,KAAa;;;ADNU;iBCiBtC,WAAA,CAAY,cAAsB;;;AAXlD;iBAsBgB,cAAA,CAAe,YAAoB;;;AAtBP;iBA6C5B,gBAAA,CAAiB,IAAA,EAAM,IAAI,EAAE,MAAA;;;;iBAsB7B,gBAAA;AA7ChB;;;AAAA,iBAoDgB,gBAAA,CAAiB,QAAgB;AApDE;AAuBnD;;AAvBmD,iBA4DnC,WAAA,CAAY,IAAU,EAAJ,IAAI;;;;iBAOtB,WAAA,CAAY,IAAU,EAAJ,IAAI;;AA5CuB;AAsB7D;iBA6BgB,WAAA,CAAY,IAAU,EAAJ,IAAI;;;AA7BN;iBAoChB,cAAA,CAAe,IAAU,EAAJ,IAAI;;;;iBAoBzB,iBAAA,CAAkB,IAAU,EAAJ,IAAI;AAzC5C;;;AAAA,iBAmDgB,iBAAA,CAAkB,UAAkB;AAnDd;AAOtC;;AAPsC,iBA0DtB,iBAAA,CAAkB,OAAA,UAAiB,KAAa"}

package/dist/utils/index.mjs

@@ -1,2 +1,2 @@
-import{t as e}from"../is-browser-file-CN7ymiO5.mjs";function t(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 n(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`${Number.parseFloat((e/t**r).toFixed(1))} ${n[r]}`}function r(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 a(){return`upload-${Date.now()}-${Math.random().toString(36).substr(2,9)}`}function o(e){let t=e.lastIndexOf(`.`);return t===-1?``:e.substring(t+1).toLowerCase()}function s(e){return e.type.startsWith(`image/`)}function c(e){return e.type.startsWith(`video/`)}function l(e){return e.type.startsWith(`audio/`)}function u(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 d(e){return s(e)||c(e)||l(e)?URL.createObjectURL(e):null}function f(e){URL.revokeObjectURL(e)}function p(e,t){return t===0?0:Math.min(100,Math.max(0,Math.round(e/t*100)))}export{p as calculateProgress,d as createFilePreview,r as formatDuration,t as formatFileSize,n as formatSpeed,a as generateUploadId,o as getFileExtension,l as isAudioFile,e as isBrowserFile,u as isDocumentFile,s as isImageFile,c as isVideoFile,f as revokeFilePreview,i as validateFileType};
+const e=e=>typeof File<`u`&&e instanceof File;function t(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 n(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`${Number.parseFloat((e/t**r).toFixed(1))} ${n[r]}`}function r(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 a(){return`upload-${Date.now()}-${Math.random().toString(36).substr(2,9)}`}function o(e){let t=e.lastIndexOf(`.`);return t===-1?``:e.substring(t+1).toLowerCase()}function s(e){return e.type.startsWith(`image/`)}function c(e){return e.type.startsWith(`video/`)}function l(e){return e.type.startsWith(`audio/`)}function u(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 d(e){return s(e)||c(e)||l(e)?URL.createObjectURL(e):null}function f(e){URL.revokeObjectURL(e)}function p(e,t){return t===0?0:Math.min(100,Math.max(0,Math.round(e/t*100)))}export{p as calculateProgress,d as createFilePreview,r as formatDuration,t as formatFileSize,n as formatSpeed,a as generateUploadId,o as getFileExtension,l as isAudioFile,e as isBrowserFile,u as isDocumentFile,s as isImageFile,c as isVideoFile,f as revokeFilePreview,i as validateFileType};
 //# sourceMappingURL=index.mjs.map

package/dist/utils/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":["/**\n * Utility functions for the Vue upload client\n */\n\n/**\n * Format file size in human-readable format\n */\nexport function formatFileSize(bytes: number): string {\n  if (bytes === 0) return \"0 Bytes\";\n  const k = 1024;\n  const sizes = [\"Bytes\", \"KB\", \"MB\", \"GB\", \"TB\"];\n  const i = Math.floor(Math.log(bytes) / Math.log(k));\n  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;\n}\n\n/**\n * Format upload speed in human-readable format\n */\nexport function formatSpeed(bytesPerSecond: number): string {\n  if (bytesPerSecond === 0) return \"0 B/s\";\n  const k = 1024;\n  const sizes = [\"B/s\", \"KB/s\", \"MB/s\", \"GB/s\"];\n  const i = Math.floor(Math.log(bytesPerSecond) / Math.log(k));\n  return `${Number.parseFloat((bytesPerSecond / k ** i).toFixed(1))} ${sizes[i]}`;\n}\n\n/**\n * Format duration in human-readable format\n */\nexport function formatDuration(milliseconds: number): string {\n  if (milliseconds < 1000) {\n    return `${Math.round(milliseconds)}ms`;\n  }\n\n  if (milliseconds < 60000) {\n    return `${Math.round(milliseconds / 1000)}s`;\n  }\n\n  if (milliseconds < 3600000) {\n    const minutes = Math.floor(milliseconds / 60000);\n    const seconds = Math.round((milliseconds % 60000) / 1000);\n    return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;\n  }\n\n  const hours = Math.floor(milliseconds / 3600000);\n  const minutes = Math.round((milliseconds % 3600000) / 60000);\n  return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;\n}\n\n/**\n * Validate file type against accepted types\n */\nexport function validateFileType(file: File, accept: string[]): boolean {\n  if (!accept || accept.length === 0) return true;\n\n  return accept.some((acceptType) => {\n    if (acceptType.startsWith(\".\")) {\n      // File extension check\n      return file.name.toLowerCase().endsWith(acceptType.toLowerCase());\n    }\n\n    // MIME type check (supports wildcards like image/*)\n    if (acceptType.endsWith(\"/*\")) {\n      const baseType = acceptType.slice(0, -2);\n      return file.type.startsWith(baseType);\n    }\n\n    return file.type === acceptType;\n  });\n}\n\n/**\n * Generate a unique ID for upload items\n */\nexport function generateUploadId(): string {\n  return `upload-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;\n}\n\n/**\n * Get file extension from filename\n */\nexport function getFileExtension(filename: string): string {\n  const lastDot = filename.lastIndexOf(\".\");\n  return lastDot !== -1 ? filename.substring(lastDot + 1).toLowerCase() : \"\";\n}\n\n/**\n * Check if a file is an image\n */\nexport function isImageFile(file: File): boolean {\n  return file.type.startsWith(\"image/\");\n}\n\n/**\n * Check if a file is a video\n */\nexport function isVideoFile(file: File): boolean {\n  return file.type.startsWith(\"video/\");\n}\n\n/**\n * Check if a file is an audio file\n */\nexport function isAudioFile(file: File): boolean {\n  return file.type.startsWith(\"audio/\");\n}\n\n/**\n * Check if a file is a document\n */\nexport function isDocumentFile(file: File): boolean {\n  const documentTypes = [\n    \"application/pdf\",\n    \"application/msword\",\n    \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\",\n    \"application/vnd.ms-excel\",\n    \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\",\n    \"application/vnd.ms-powerpoint\",\n    \"application/vnd.openxmlformats-officedocument.presentationml.presentation\",\n    \"text/plain\",\n    \"text/csv\",\n    \"application/rtf\",\n  ];\n\n  return documentTypes.includes(file.type);\n}\n\n/**\n * Create a preview URL for a file (if supported)\n */\nexport function createFilePreview(file: File): string | null {\n  if (isImageFile(file) || isVideoFile(file) || isAudioFile(file)) {\n    return URL.createObjectURL(file);\n  }\n  return null;\n}\n\n/**\n * Clean up a preview URL created with createFilePreview\n */\nexport function revokeFilePreview(previewUrl: string): void {\n  URL.revokeObjectURL(previewUrl);\n}\n\n/**\n * Calculate progress percentage\n */\nexport function calculateProgress(current: number, total: number): number {\n  if (total === 0) return 0;\n  return Math.min(100, Math.max(0, Math.round((current / total) * 100)));\n}\n\n/**\n * Check if a value is a browser file\n */\nexport * from \"./is-browser-file\";\n"],"mappings":"oDAOA,SAAgB,EAAe,EAAuB,CACpD,GAAI,IAAU,EAAG,MAAO,UACxB,IAAM,EAAI,KACJ,EAAQ,CAAC,QAAS,KAAM,KAAM,KAAM,KAAK,CACzC,EAAI,KAAK,MAAM,KAAK,IAAI,EAAM,CAAG,KAAK,IAAI,EAAE,CAAC,CACnD,MAAO,GAAG,OAAO,YAAY,EAAQ,GAAK,GAAG,QAAQ,EAAE,CAAC,CAAC,GAAG,EAAM,KAMpE,SAAgB,EAAY,EAAgC,CAC1D,GAAI,IAAmB,EAAG,MAAO,QACjC,IAAM,EAAI,KACJ,EAAQ,CAAC,MAAO,OAAQ,OAAQ,OAAO,CACvC,EAAI,KAAK,MAAM,KAAK,IAAI,EAAe,CAAG,KAAK,IAAI,EAAE,CAAC,CAC5D,MAAO,GAAG,OAAO,YAAY,EAAiB,GAAK,GAAG,QAAQ,EAAE,CAAC,CAAC,GAAG,EAAM,KAM7E,SAAgB,EAAe,EAA8B,CAC3D,GAAI,EAAe,IACjB,MAAO,GAAG,KAAK,MAAM,EAAa,CAAC,IAGrC,GAAI,EAAe,IACjB,MAAO,GAAG,KAAK,MAAM,EAAe,IAAK,CAAC,GAG5C,GAAI,EAAe,KAAS,CAC1B,IAAM,EAAU,KAAK,MAAM,EAAe,IAAM,CAC1C,EAAU,KAAK,MAAO,EAAe,IAAS,IAAK,CACzD,OAAO,EAAU,EAAI,GAAG,EAAQ,IAAI,EAAQ,GAAK,GAAG,EAAQ,GAG9D,IAAM,EAAQ,KAAK,MAAM,EAAe,KAAQ,CAC1C,EAAU,KAAK,MAAO,EAAe,KAAW,IAAM,CAC5D,OAAO,EAAU,EAAI,GAAG,EAAM,IAAI,EAAQ,GAAK,GAAG,EAAM,GAM1D,SAAgB,EAAiB,EAAY,EAA2B,CAGtE,MAFI,CAAC,GAAU,EAAO,SAAW,EAAU,GAEpC,EAAO,KAAM,GAAe,CACjC,GAAI,EAAW,WAAW,IAAI,CAE5B,OAAO,EAAK,KAAK,aAAa,CAAC,SAAS,EAAW,aAAa,CAAC,CAInE,GAAI,EAAW,SAAS,KAAK,CAAE,CAC7B,IAAM,EAAW,EAAW,MAAM,EAAG,GAAG,CACxC,OAAO,EAAK,KAAK,WAAW,EAAS,CAGvC,OAAO,EAAK,OAAS,GACrB,CAMJ,SAAgB,GAA2B,CACzC,MAAO,UAAU,KAAK,KAAK,CAAC,GAAG,KAAK,QAAQ,CAAC,SAAS,GAAG,CAAC,OAAO,EAAG,EAAE,GAMxE,SAAgB,EAAiB,EAA0B,CACzD,IAAM,EAAU,EAAS,YAAY,IAAI,CACzC,OAAO,IAAY,GAAqD,GAAhD,EAAS,UAAU,EAAU,EAAE,CAAC,aAAa,CAMvE,SAAgB,EAAY,EAAqB,CAC/C,OAAO,EAAK,KAAK,WAAW,SAAS,CAMvC,SAAgB,EAAY,EAAqB,CAC/C,OAAO,EAAK,KAAK,WAAW,SAAS,CAMvC,SAAgB,EAAY,EAAqB,CAC/C,OAAO,EAAK,KAAK,WAAW,SAAS,CAMvC,SAAgB,EAAe,EAAqB,CAclD,MAbsB,CACpB,kBACA,qBACA,0EACA,2BACA,oEACA,gCACA,4EACA,aACA,WACA,kBACD,CAEoB,SAAS,EAAK,KAAK,CAM1C,SAAgB,EAAkB,EAA2B,CAI3D,OAHI,EAAY,EAAK,EAAI,EAAY,EAAK,EAAI,EAAY,EAAK,CACtD,IAAI,gBAAgB,EAAK,CAE3B,KAMT,SAAgB,EAAkB,EAA0B,CAC1D,IAAI,gBAAgB,EAAW,CAMjC,SAAgB,EAAkB,EAAiB,EAAuB,CAExE,OADI,IAAU,EAAU,EACjB,KAAK,IAAI,IAAK,KAAK,IAAI,EAAG,KAAK,MAAO,EAAU,EAAS,IAAI,CAAC,CAAC"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/utils/is-browser-file.ts","../../src/utils/index.ts"],"sourcesContent":["export const isBrowserFile = (value: unknown): value is File =>\n  typeof File !== \"undefined\" && value instanceof File;\n","/**\n * Utility functions for the Vue upload client\n */\n\n/**\n * Format file size in human-readable format\n */\nexport function formatFileSize(bytes: number): string {\n  if (bytes === 0) return \"0 Bytes\";\n  const k = 1024;\n  const sizes = [\"Bytes\", \"KB\", \"MB\", \"GB\", \"TB\"];\n  const i = Math.floor(Math.log(bytes) / Math.log(k));\n  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;\n}\n\n/**\n * Format upload speed in human-readable format\n */\nexport function formatSpeed(bytesPerSecond: number): string {\n  if (bytesPerSecond === 0) return \"0 B/s\";\n  const k = 1024;\n  const sizes = [\"B/s\", \"KB/s\", \"MB/s\", \"GB/s\"];\n  const i = Math.floor(Math.log(bytesPerSecond) / Math.log(k));\n  return `${Number.parseFloat((bytesPerSecond / k ** i).toFixed(1))} ${sizes[i]}`;\n}\n\n/**\n * Format duration in human-readable format\n */\nexport function formatDuration(milliseconds: number): string {\n  if (milliseconds < 1000) {\n    return `${Math.round(milliseconds)}ms`;\n  }\n\n  if (milliseconds < 60000) {\n    return `${Math.round(milliseconds / 1000)}s`;\n  }\n\n  if (milliseconds < 3600000) {\n    const minutes = Math.floor(milliseconds / 60000);\n    const seconds = Math.round((milliseconds % 60000) / 1000);\n    return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;\n  }\n\n  const hours = Math.floor(milliseconds / 3600000);\n  const minutes = Math.round((milliseconds % 3600000) / 60000);\n  return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;\n}\n\n/**\n * Validate file type against accepted types\n */\nexport function validateFileType(file: File, accept: string[]): boolean {\n  if (!accept || accept.length === 0) return true;\n\n  return accept.some((acceptType) => {\n    if (acceptType.startsWith(\".\")) {\n      // File extension check\n      return file.name.toLowerCase().endsWith(acceptType.toLowerCase());\n    }\n\n    // MIME type check (supports wildcards like image/*)\n    if (acceptType.endsWith(\"/*\")) {\n      const baseType = acceptType.slice(0, -2);\n      return file.type.startsWith(baseType);\n    }\n\n    return file.type === acceptType;\n  });\n}\n\n/**\n * Generate a unique ID for upload items\n */\nexport function generateUploadId(): string {\n  return `upload-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;\n}\n\n/**\n * Get file extension from filename\n */\nexport function getFileExtension(filename: string): string {\n  const lastDot = filename.lastIndexOf(\".\");\n  return lastDot !== -1 ? filename.substring(lastDot + 1).toLowerCase() : \"\";\n}\n\n/**\n * Check if a file is an image\n */\nexport function isImageFile(file: File): boolean {\n  return file.type.startsWith(\"image/\");\n}\n\n/**\n * Check if a file is a video\n */\nexport function isVideoFile(file: File): boolean {\n  return file.type.startsWith(\"video/\");\n}\n\n/**\n * Check if a file is an audio file\n */\nexport function isAudioFile(file: File): boolean {\n  return file.type.startsWith(\"audio/\");\n}\n\n/**\n * Check if a file is a document\n */\nexport function isDocumentFile(file: File): boolean {\n  const documentTypes = [\n    \"application/pdf\",\n    \"application/msword\",\n    \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\",\n    \"application/vnd.ms-excel\",\n    \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\",\n    \"application/vnd.ms-powerpoint\",\n    \"application/vnd.openxmlformats-officedocument.presentationml.presentation\",\n    \"text/plain\",\n    \"text/csv\",\n    \"application/rtf\",\n  ];\n\n  return documentTypes.includes(file.type);\n}\n\n/**\n * Create a preview URL for a file (if supported)\n */\nexport function createFilePreview(file: File): string | null {\n  if (isImageFile(file) || isVideoFile(file) || isAudioFile(file)) {\n    return URL.createObjectURL(file);\n  }\n  return null;\n}\n\n/**\n * Clean up a preview URL created with createFilePreview\n */\nexport function revokeFilePreview(previewUrl: string): void {\n  URL.revokeObjectURL(previewUrl);\n}\n\n/**\n * Calculate progress percentage\n */\nexport function calculateProgress(current: number, total: number): number {\n  if (total === 0) return 0;\n  return Math.min(100, Math.max(0, Math.round((current / total) * 100)));\n}\n\n/**\n * Check if a value is a browser file\n */\nexport * from \"./is-browser-file\";\n"],"mappings":"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"}