@chunkflowjs/upload-client-vue 0.0.1-alpha.1

package/README.md

@@ -0,0 +1,230 @@
+# @chunkflowjs/upload-client-vue
+
+Vue adapter for ChunkFlow Upload SDK with composables and plugin.
+
+## Installation
+
+```bash
+npm install @chunkflowjs/upload-client-vue
+# or
+pnpm add @chunkflowjs/upload-client-vue
+# or
+yarn add @chunkflowjs/upload-client-vue
+```
+
+## Usage
+
+### 1. Install the Plugin
+
+First, install the Upload Plugin in your Vue application:
+
+```typescript
+// main.ts
+import { createApp } from "vue";
+import { createUploadPlugin } from "@chunkflowjs/upload-client-vue";
+import App from "./App.vue";
+
+// Create your request adapter
+const requestAdapter = {
+  createFile: async (request) => {
+    // Implement your API call
+  },
+  verifyHash: async (request) => {
+    // Implement your API call
+  },
+  uploadChunk: async (request) => {
+    // Implement your API call
+  },
+  mergeFile: async (request) => {
+    // Implement your API call
+  },
+};
+
+const app = createApp(App);
+
+// Install the upload plugin
+const uploadPlugin = createUploadPlugin({
+  requestAdapter,
+  managerOptions: {
+    maxConcurrentTasks: 5,
+    defaultChunkSize: 2 * 1024 * 1024, // 2MB
+    defaultConcurrency: 3,
+  },
+});
+
+app.use(uploadPlugin);
+app.mount("#app");
+```
+
+### 2. Use the Composables
+
+#### Single File Upload with `useUpload`
+
+```vue
+<script setup lang="ts">
+import { useUpload } from "@chunkflowjs/upload-client-vue";
+
+const { upload, pause, resume, cancel, status, progress, error } = useUpload({
+  onSuccess: (fileUrl) => {
+    console.log("Upload complete:", fileUrl);
+  },
+  onError: (error) => {
+    console.error("Upload failed:", error);
+  },
+  onProgress: (progress) => {
+    console.log(`Progress: ${progress.percentage}%`);
+  },
+});
+
+const handleFileSelect = (event: Event) => {
+  const input = event.target as HTMLInputElement;
+  const file = input.files?.[0];
+  if (file) {
+    upload(file);
+  }
+};
+</script>
+
+<template>
+  <div>
+    <input type="file" @change="handleFileSelect" />
+
+    <div v-if="status === 'uploading'">
+      <p>Progress: {{ progress.percentage.toFixed(1) }}%</p>
+      <p>Speed: {{ (progress.speed / 1024 / 1024).toFixed(2) }} MB/s</p>
+      <p>Remaining: {{ Math.ceil(progress.remainingTime) }}s</p>
+      <button @click="pause">Pause</button>
+      <button @click="cancel">Cancel</button>
+    </div>
+
+    <button v-if="status === 'paused'" @click="resume">Resume</button>
+    <p v-if="status === 'success'">Upload complete!</p>
+    <p v-if="status === 'error'">Error: {{ error?.message }}</p>
+  </div>
+</template>
+```
+
+#### Multiple File Upload with `useUploadList`
+
+```vue
+<script setup lang="ts">
+import { useUploadList } from "@chunkflowjs/upload-client-vue";
+
+const {
+  tasks,
+  uploadFiles,
+  pauseAll,
+  resumeAll,
+  cancelAll,
+  removeTask,
+  clearCompleted,
+  getStatistics,
+} = useUploadList();
+
+const handleFilesSelect = (event: Event) => {
+  const input = event.target as HTMLInputElement;
+  const files = Array.from(input.files || []);
+  uploadFiles(files);
+};
+
+const stats = getStatistics();
+</script>
+
+<template>
+  <div>
+    <input type="file" multiple @change="handleFilesSelect" />
+
+    <div>
+      <button @click="pauseAll">Pause All</button>
+      <button @click="resumeAll">Resume All</button>
+      <button @click="cancelAll">Cancel All</button>
+      <button @click="clearCompleted">Clear Completed</button>
+    </div>
+
+    <p>
+      Total: {{ stats.total }} | Uploading: {{ stats.uploading }} | Success: {{ stats.success }} |
+      Error: {{ stats.error }}
+    </p>
+
+    <ul>
+      <li v-for="task in tasks" :key="task.id">
+        <span>{{ task.file.name }}</span>
+        <span>{{ task.getStatus() }}</span>
+        <span>{{ task.getProgress().percentage.toFixed(1) }}%</span>
+        <button @click="removeTask(task.id)">Remove</button>
+      </li>
+    </ul>
+  </div>
+</template>
+```
+
+## API
+
+### `createUploadPlugin(options)`
+
+Creates a Vue plugin for the Upload SDK.
+
+**Options:**
+
+- `requestAdapter` (required): Implementation of the RequestAdapter interface
+- `managerOptions` (optional): Configuration for the UploadManager
+  - `maxConcurrentTasks`: Maximum number of concurrent upload tasks (default: 3)
+  - `defaultChunkSize`: Default chunk size in bytes (default: 1MB)
+  - `defaultConcurrency`: Default number of concurrent chunk uploads per task (default: 3)
+  - `autoResumeUnfinished`: Automatically resume unfinished uploads on init (default: true)
+
+### `useUpload(options)`
+
+Composable for uploading a single file.
+
+**Options:**
+
+- `chunkSize`: Chunk size in bytes
+- `concurrency`: Number of concurrent chunk uploads
+- `retryCount`: Number of retry attempts for failed chunks
+- `retryDelay`: Delay between retries in milliseconds
+- `onSuccess`: Callback when upload succeeds
+- `onError`: Callback when upload fails
+- `onProgress`: Callback on progress updates
+- `onStart`: Callback when upload starts
+- `onPause`: Callback when upload is paused
+- `onResume`: Callback when upload is resumed
+- `onCancel`: Callback when upload is cancelled
+
+**Returns:**
+
+- `upload(file)`: Function to start uploading a file
+- `pause()`: Function to pause the upload
+- `resume()`: Function to resume the upload
+- `cancel()`: Function to cancel the upload
+- `status`: Reactive ref with current upload status
+- `progress`: Reactive ref with current upload progress
+- `error`: Reactive ref with error if upload failed
+- `task`: Reactive ref with the current upload task
+
+### `useUploadList()`
+
+Composable for managing multiple file uploads.
+
+**Returns:**
+
+- `tasks`: Reactive ref with array of all upload tasks
+- `uploadFiles(files)`: Function to upload multiple files
+- `pauseAll()`: Function to pause all uploads
+- `resumeAll()`: Function to resume all uploads
+- `cancelAll()`: Function to cancel all uploads
+- `removeTask(taskId)`: Function to remove a specific task
+- `clearCompleted()`: Function to clear all completed tasks
+- `getStatistics()`: Function to get task statistics
+
+### `useUploadManager()`
+
+Composable for accessing the UploadManager instance directly.
+
+**Returns:**
+
+- `manager`: The UploadManager instance
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,61 @@
+import { UploadManager, UploadManager as UploadManager$1, UploadManagerOptions, UploadManagerOptions as UploadManagerOptions$1, UploadTask, UploadTask as UploadTask$1, UploadTaskOptions, UploadTaskOptions as UploadTaskOptions$1 } from "@chunkflowjs/core";
+import { Plugin, Ref } from "vue";
+import { ChunkInfo, FileInfo, RequestAdapter, RequestAdapter as RequestAdapter$1, UploadProgress, UploadProgress as UploadProgress$1, UploadStatus, UploadStatus as UploadStatus$1, UploadToken } from "@chunkflowjs/protocol";
+
+//#region src/plugin.d.ts
+declare const UPLOAD_MANAGER_KEY: unique symbol;
+interface UploadPluginOptions {
+  requestAdapter: RequestAdapter$1;
+  managerOptions?: Partial<UploadManagerOptions$1>;
+}
+declare function createUploadPlugin(options: UploadPluginOptions): Plugin;
+declare const _default: Plugin<UploadPluginOptions>;
+//#endregion
+//#region src/useUploadManager.d.ts
+declare function useUploadManager(): UploadManager$1;
+//#endregion
+//#region src/useUpload.d.ts
+interface UseUploadOptions extends Partial<UploadTaskOptions$1> {
+  onSuccess?: (fileUrl: string) => void;
+  onError?: (error: Error) => void;
+  onProgress?: (progress: UploadProgress$1) => void;
+  onStart?: () => void;
+  onPause?: () => void;
+  onResume?: () => void;
+  onCancel?: () => void;
+}
+interface UseUploadReturn {
+  upload: (file: File) => void;
+  pause: () => void;
+  resume: () => void;
+  cancel: () => void;
+  status: Ref<UploadStatus$1>;
+  progress: Ref<UploadProgress$1>;
+  error: Ref<Error | null>;
+  task: Ref<UploadTask$1 | null>;
+}
+declare function useUpload(options?: UseUploadOptions): UseUploadReturn;
+//#endregion
+//#region src/useUploadList.d.ts
+interface UseUploadListReturn {
+  tasks: Ref<UploadTask$1[]>;
+  uploadFiles: (files: File[]) => void;
+  pauseAll: () => void;
+  resumeAll: () => void;
+  cancelAll: () => void;
+  removeTask: (taskId: string) => void;
+  clearCompleted: () => void;
+  getStatistics: () => {
+    total: number;
+    idle: number;
+    uploading: number;
+    paused: number;
+    success: number;
+    error: number;
+    cancelled: number;
+  };
+}
+declare function useUploadList(): UseUploadListReturn;
+//#endregion
+export { type ChunkInfo, type FileInfo, type RequestAdapter, UPLOAD_MANAGER_KEY, type UploadManager, type UploadManagerOptions, _default as UploadPlugin, type UploadPluginOptions, type UploadProgress, type UploadStatus, type UploadTask, type UploadTaskOptions, type UploadToken, type UseUploadListReturn, type UseUploadOptions, type UseUploadReturn, createUploadPlugin, useUpload, useUploadList, useUploadManager };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/plugin.ts","../src/useUploadManager.ts","../src/useUpload.ts","../src/useUploadList.ts"],"mappings":";;;;;cAsBa,kBAAA;AAAA,UAKI,mBAAA;EAEf,cAAA,EAAgB,gBAAA;EAEhB,cAAA,GAAiB,OAAA,CAAQ,sBAAA;AAAA;AAAA,iBAuCX,kBAAA,CAAmB,OAAA,EAAS,mBAAA,GAAsB,MAAA;AAAA,cAmCjE,QAAA,EAgBI,MAAA,CAAO,mBAAA;;;iBCjFI,gBAAA,CAAA,GAAoB,eAAA;;;UCrBnB,gBAAA,SAAyB,OAAA,CAAQ,mBAAA;EAEhD,SAAA,IAAa,OAAA;EAEb,OAAA,IAAW,KAAA,EAAO,KAAA;EAElB,UAAA,IAAc,QAAA,EAAU,gBAAA;EAExB,OAAA;EAEA,OAAA;EAEA,QAAA;EAEA,QAAA;AAAA;AAAA,UAMe,eAAA;EAEf,MAAA,GAAS,IAAA,EAAM,IAAA;EAEf,KAAA;EAEA,MAAA;EAEA,MAAA;EAEA,MAAA,EAAQ,GAAA,CAAI,cAAA;EAEZ,QAAA,EAAU,GAAA,CAAI,gBAAA;EAEd,KAAA,EAAO,GAAA,CAAI,KAAA;EAEX,IAAA,EAAM,GAAA,CAAI,YAAA;AAAA;AAAA,iBA8DI,SAAA,CAAU,OAAA,GAAS,gBAAA,GAAwB,eAAA;;;UCnG1C,mBAAA;EAEf,KAAA,EAAO,GAAA,CAAI,YAAA;EAEX,WAAA,GAAc,KAAA,EAAO,IAAA;EAErB,QAAA;EAEA,SAAA;EAEA,SAAA;EAEA,UAAA,GAAa,MAAA;EAEb,cAAA;EAEA,aAAA;IACE,KAAA;IACA,IAAA;IACA,SAAA;IACA,MAAA;IACA,OAAA;IACA,KAAA;IACA,SAAA;EAAA;AAAA;AAAA,iBAqEY,aAAA,CAAA,GAAiB,mBAAA"}

package/dist/index.mjs

@@ -0,0 +1,419 @@
+import { UploadManager } from "@chunkflowjs/core";
+import { inject, onMounted, onUnmounted, ref } from "vue";
+
+//#region src/plugin.ts
+/**
+* Injection key for UploadManager
+*
+* Use this key with inject() to access the UploadManager instance.
+* Prefer using the useUploadManager() composable instead.
+*/
+const UPLOAD_MANAGER_KEY = Symbol("uploadManager");
+/**
+* Vue Plugin for ChunkFlow Upload SDK
+*
+* Install this plugin in your Vue application to enable upload functionality.
+* Creates and manages a single UploadManager instance for the entire app.
+*
+* @remarks
+* - Validates: Requirement 10.2 (Vue Composables)
+* - Validates: Requirement 10.3 (auto-initialize on install)
+* - Validates: Requirement 10.4 (auto-cleanup on unmount)
+* - Creates UploadManager instance on install
+* - Provides manager via Vue's provide/inject
+* - Initializes manager automatically
+* - Cleans up manager on app unmount
+*
+* @example
+* ```typescript
+* import { createApp } from 'vue';
+* import { createUploadPlugin } from '@chunkflowjs/upload-client-vue';
+* import { myRequestAdapter } from './api';
+* import App from './App.vue';
+*
+* const app = createApp(App);
+*
+* const uploadPlugin = createUploadPlugin({
+*   requestAdapter: myRequestAdapter,
+*   managerOptions: {
+*     maxConcurrentTasks: 5,
+*     defaultChunkSize: 2 * 1024 * 1024, // 2MB
+*   },
+* });
+*
+* app.use(uploadPlugin);
+* app.mount('#app');
+* ```
+*/
+function createUploadPlugin(options) {
+	const { requestAdapter, managerOptions } = options;
+	return { install(app) {
+		const manager = new UploadManager({
+			requestAdapter,
+			...managerOptions
+		});
+		app.provide(UPLOAD_MANAGER_KEY, manager);
+		manager.init().catch((error) => {
+			console.error("Failed to initialize UploadManager:", error);
+		});
+		const originalUnmount = app.unmount.bind(app);
+		app.unmount = () => {
+			manager.close();
+			originalUnmount();
+		};
+	} };
+}
+/**
+* Default export for convenience
+*
+* @example
+* ```typescript
+* import UploadPlugin from '@chunkflowjs/upload-client-vue';
+* app.use(UploadPlugin, { requestAdapter: myAdapter });
+* ```
+*/
+var plugin_default = { install(app, options) {
+	createUploadPlugin(options).install(app);
+} };
+
+//#endregion
+//#region src/useUploadManager.ts
+/**
+* useUploadManager - Vue Composable for accessing UploadManager
+*
+* Provides access to the UploadManager instance via Vue's inject API.
+* Must be used within a component that has the Upload Plugin installed.
+*
+* @remarks
+* - Validates: Requirement 10.2 (Vue Composables)
+*/
+/**
+* Composable for accessing the UploadManager instance
+*
+* Retrieves the UploadManager instance provided by the Upload Plugin.
+* Throws an error if used outside of a component tree with the plugin installed.
+*
+* @returns The UploadManager instance
+* @throws Error if Upload Plugin is not installed
+*
+* @remarks
+* - Validates: Requirement 10.2 (Vue Composables)
+* - Uses Vue's inject API
+* - Validates plugin installation
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+* import { useUploadManager } from '@chunkflowjs/upload-client-vue';
+*
+* const manager = useUploadManager();
+*
+* // Use manager to create tasks, etc.
+* const task = manager.createTask(file);
+* <\/script>
+* ```
+*/
+function useUploadManager() {
+	const manager = inject(UPLOAD_MANAGER_KEY);
+	if (!manager) throw new Error("useUploadManager must be used within a component tree that has the Upload Plugin installed. Make sure you have called app.use(createUploadPlugin({ ... })) in your main.ts file.");
+	return manager;
+}
+
+//#endregion
+//#region src/useUpload.ts
+/**
+* useUpload - Vue Composable for single file upload
+*
+* Provides a simple interface for uploading a single file with reactive state.
+* Handles task creation, lifecycle events, and state management.
+*
+* @remarks
+* - Validates: Requirement 10.2 (Vue Composables)
+* - Validates: Requirement 10.5 (reactive upload state)
+*/
+/**
+* Composable for uploading a single file
+*
+* Provides reactive state and control functions for file upload.
+* Automatically manages task lifecycle and updates reactive state.
+*
+* @param options - Configuration options and callbacks
+* @returns Upload control functions and reactive state
+*
+* @remarks
+* - Validates: Requirement 10.2 (Vue Composables)
+* - Validates: Requirement 10.5 (reactive state)
+* - Creates new task for each upload
+* - Automatically subscribes to task events
+* - Updates reactive state on events
+* - Cleans up event listeners on unmount
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+* import { useUpload } from '@chunkflowjs/upload-client-vue';
+*
+* const { upload, pause, resume, cancel, status, progress, error } = useUpload({
+*   onSuccess: (fileUrl) => {
+*     console.log('Upload complete:', fileUrl);
+*   },
+*   onError: (error) => {
+*     console.error('Upload failed:', error);
+*   },
+*   onProgress: (progress) => {
+*     console.log(`Progress: ${progress.percentage}%`);
+*   },
+* });
+*
+* const handleFileSelect = (event: Event) => {
+*   const input = event.target as HTMLInputElement;
+*   const file = input.files?.[0];
+*   if (file) {
+*     upload(file);
+*   }
+* };
+* <\/script>
+*
+* <template>
+*   <div>
+*     <input type="file" @change="handleFileSelect" />
+*     <div v-if="status === 'uploading'">
+*       <p>Progress: {{ progress.percentage.toFixed(1) }}%</p>
+*       <p>Speed: {{ (progress.speed / 1024 / 1024).toFixed(2) }} MB/s</p>
+*       <button @click="pause">Pause</button>
+*       <button @click="cancel">Cancel</button>
+*     </div>
+*     <button v-if="status === 'paused'" @click="resume">Resume</button>
+*     <p v-if="status === 'success'">Upload complete!</p>
+*     <p v-if="status === 'error'">Error: {{ error?.message }}</p>
+*   </div>
+* </template>
+* ```
+*/
+function useUpload(options = {}) {
+	const manager = useUploadManager();
+	const task = ref(null);
+	const status = ref("idle");
+	const progress = ref({
+		uploadedBytes: 0,
+		totalBytes: 0,
+		percentage: 0,
+		speed: 0,
+		remainingTime: 0,
+		uploadedChunks: 0,
+		totalChunks: 0
+	});
+	const error = ref(null);
+	const upload = (file) => {
+		error.value = null;
+		status.value = "idle";
+		const newTask = manager.createTask(file, {
+			chunkSize: options.chunkSize,
+			concurrency: options.concurrency,
+			retryCount: options.retryCount,
+			retryDelay: options.retryDelay,
+			autoStart: false
+		});
+		newTask.on("start", () => {
+			status.value = "uploading";
+			options.onStart?.();
+		});
+		newTask.on("progress", () => {
+			const progressData = newTask.getProgress();
+			progress.value = progressData;
+			options.onProgress?.(progressData);
+		});
+		newTask.on("success", ({ fileUrl }) => {
+			status.value = "success";
+			options.onSuccess?.(fileUrl);
+		});
+		newTask.on("error", ({ error: err }) => {
+			status.value = "error";
+			error.value = err;
+			options.onError?.(err);
+		});
+		newTask.on("pause", () => {
+			status.value = "paused";
+			options.onPause?.();
+		});
+		newTask.on("resume", () => {
+			status.value = "uploading";
+			options.onResume?.();
+		});
+		newTask.on("cancel", () => {
+			status.value = "cancelled";
+			options.onCancel?.();
+		});
+		task.value = newTask;
+		newTask.start().catch((err) => {
+			console.error("Upload failed:", err);
+		});
+	};
+	const pause = () => {
+		task.value?.pause();
+	};
+	const resume = () => {
+		task.value?.resume().catch((err) => {
+			console.error("Resume failed:", err);
+		});
+	};
+	const cancel = () => {
+		task.value?.cancel();
+	};
+	onUnmounted(() => {
+		if (task.value) {
+			const currentStatus = task.value.getStatus();
+			if (currentStatus === "uploading" || currentStatus === "paused") task.value.cancel();
+		}
+	});
+	return {
+		upload,
+		pause,
+		resume,
+		cancel,
+		status,
+		progress,
+		error,
+		task
+	};
+}
+
+//#endregion
+//#region src/useUploadList.ts
+/**
+* useUploadList - Vue Composable for managing multiple file uploads
+*
+* Provides reactive state and control functions for managing a list of upload tasks.
+* Automatically syncs with the UploadManager's task list.
+*
+* @remarks
+* - Validates: Requirement 10.2 (Vue Composables)
+* - Validates: Requirement 10.5 (reactive state)
+*/
+/**
+* Composable for managing multiple file uploads
+*
+* Provides reactive state for all upload tasks and batch control functions.
+* Automatically updates when tasks are added, removed, or change state.
+*
+* @returns Upload list control functions and reactive state
+*
+* @remarks
+* - Validates: Requirement 10.2 (Vue Composables)
+* - Validates: Requirement 10.5 (reactive state)
+* - Polls manager for task updates (100ms interval)
+* - Provides batch operations for all tasks
+* - Automatically cleans up on unmount
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+* import { useUploadList } from '@chunkflowjs/upload-client-vue';
+*
+* const {
+*   tasks,
+*   uploadFiles,
+*   pauseAll,
+*   resumeAll,
+*   cancelAll,
+*   removeTask,
+*   clearCompleted,
+*   getStatistics,
+* } = useUploadList();
+*
+* const handleFilesSelect = (event: Event) => {
+*   const input = event.target as HTMLInputElement;
+*   const files = Array.from(input.files || []);
+*   uploadFiles(files);
+* };
+*
+* const stats = getStatistics();
+* <\/script>
+*
+* <template>
+*   <div>
+*     <input type="file" multiple @change="handleFilesSelect" />
+*     <div>
+*       <button @click="pauseAll">Pause All</button>
+*       <button @click="resumeAll">Resume All</button>
+*       <button @click="cancelAll">Cancel All</button>
+*       <button @click="clearCompleted">Clear Completed</button>
+*     </div>
+*     <p>
+*       Total: {{ stats.total }} | Uploading: {{ stats.uploading }} |
+*       Success: {{ stats.success }} | Error: {{ stats.error }}
+*     </p>
+*     <ul>
+*       <li v-for="task in tasks" :key="task.id">
+*         <span>{{ task.file.name }}</span>
+*         <span>{{ task.getStatus() }}</span>
+*         <span>{{ task.getProgress().percentage.toFixed(1) }}%</span>
+*         <button @click="removeTask(task.id)">Remove</button>
+*       </li>
+*     </ul>
+*   </div>
+* </template>
+* ```
+*/
+function useUploadList() {
+	const manager = useUploadManager();
+	const tasks = ref([]);
+	let intervalId = null;
+	onMounted(() => {
+		tasks.value = manager.getAllTasks();
+		intervalId = setInterval(() => {
+			tasks.value = manager.getAllTasks();
+		}, 100);
+	});
+	onUnmounted(() => {
+		if (intervalId !== null) {
+			clearInterval(intervalId);
+			intervalId = null;
+		}
+	});
+	const uploadFiles = (files) => {
+		files.forEach((file) => {
+			manager.createTask(file).start().catch((error) => {
+				console.error(`Failed to upload ${file.name}:`, error);
+			});
+		});
+	};
+	const pauseAll = () => {
+		manager.pauseAll();
+	};
+	const resumeAll = () => {
+		manager.resumeAll().catch((error) => {
+			console.error("Failed to resume all uploads:", error);
+		});
+	};
+	const cancelAll = () => {
+		manager.cancelAll();
+	};
+	const removeTask = (taskId) => {
+		manager.deleteTask(taskId).catch((error) => {
+			console.error(`Failed to remove task ${taskId}:`, error);
+		});
+	};
+	const clearCompleted = () => {
+		manager.clearCompletedTasks().catch((error) => {
+			console.error("Failed to clear completed tasks:", error);
+		});
+	};
+	const getStatistics = () => {
+		return manager.getStatistics();
+	};
+	return {
+		tasks,
+		uploadFiles,
+		pauseAll,
+		resumeAll,
+		cancelAll,
+		removeTask,
+		clearCompleted,
+		getStatistics
+	};
+}
+
+//#endregion
+export { UPLOAD_MANAGER_KEY, plugin_default as UploadPlugin, createUploadPlugin, useUpload, useUploadList, useUploadManager };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/plugin.ts","../src/useUploadManager.ts","../src/useUpload.ts","../src/useUploadList.ts"],"sourcesContent":["/**\n * Vue Plugin for ChunkFlow Upload SDK\n *\n * Provides UploadManager instance to Vue application via provide/inject.\n * Handles initialization and cleanup of the manager.\n *\n * @remarks\n * - Validates: Requirement 10.2 (Vue Composables integration)\n * - Validates: Requirement 10.3 (auto-initialize on mount)\n * - Validates: Requirement 10.4 (auto-cleanup on unmount)\n */\n\nimport type { App, Plugin } from \"vue\";\nimport { UploadManager, type UploadManagerOptions } from \"@chunkflowjs/core\";\nimport type { RequestAdapter } from \"@chunkflowjs/protocol\";\n\n/**\n * Injection key for UploadManager\n *\n * Use this key with inject() to access the UploadManager instance.\n * Prefer using the useUploadManager() composable instead.\n */\nexport const UPLOAD_MANAGER_KEY = Symbol(\"uploadManager\");\n\n/**\n * Options for the Upload Plugin\n */\nexport interface UploadPluginOptions {\n  /** Request adapter for API calls (required) */\n  requestAdapter: RequestAdapter;\n  /** Optional configuration for the UploadManager */\n  managerOptions?: Partial<UploadManagerOptions>;\n}\n\n/**\n * Vue Plugin for ChunkFlow Upload SDK\n *\n * Install this plugin in your Vue application to enable upload functionality.\n * Creates and manages a single UploadManager instance for the entire app.\n *\n * @remarks\n * - Validates: Requirement 10.2 (Vue Composables)\n * - Validates: Requirement 10.3 (auto-initialize on install)\n * - Validates: Requirement 10.4 (auto-cleanup on unmount)\n * - Creates UploadManager instance on install\n * - Provides manager via Vue's provide/inject\n * - Initializes manager automatically\n * - Cleans up manager on app unmount\n *\n * @example\n * ```typescript\n * import { createApp } from 'vue';\n * import { createUploadPlugin } from '@chunkflowjs/upload-client-vue';\n * import { myRequestAdapter } from './api';\n * import App from './App.vue';\n *\n * const app = createApp(App);\n *\n * const uploadPlugin = createUploadPlugin({\n *   requestAdapter: myRequestAdapter,\n *   managerOptions: {\n *     maxConcurrentTasks: 5,\n *     defaultChunkSize: 2 * 1024 * 1024, // 2MB\n *   },\n * });\n *\n * app.use(uploadPlugin);\n * app.mount('#app');\n * ```\n */\nexport function createUploadPlugin(options: UploadPluginOptions): Plugin {\n  const { requestAdapter, managerOptions } = options;\n\n  // Create the plugin object\n  const plugin: Plugin = {\n    install(app: App) {\n      // Create UploadManager instance\n      const manager = new UploadManager({\n        requestAdapter,\n        ...managerOptions,\n      });\n\n      // Provide manager to all components\n      // Requirement 10.2: Vue provide/inject mechanism\n      app.provide(UPLOAD_MANAGER_KEY, manager);\n\n      // Initialize manager\n      // Requirement 10.3: Auto-initialize on install\n      manager.init().catch((error) => {\n        console.error(\"Failed to initialize UploadManager:\", error);\n      });\n\n      // Cleanup on app unmount\n      // Requirement 10.4: Auto-cleanup on unmount\n      // Note: Vue 3 doesn't have a built-in unmount hook for plugins,\n      // but we can use the app's unmount lifecycle\n      const originalUnmount = app.unmount.bind(app);\n      app.unmount = () => {\n        manager.close();\n        originalUnmount();\n      };\n    },\n  };\n\n  return plugin;\n}\n\n/**\n * Default export for convenience\n *\n * @example\n * ```typescript\n * import UploadPlugin from '@chunkflowjs/upload-client-vue';\n * app.use(UploadPlugin, { requestAdapter: myAdapter });\n * ```\n */\nexport default {\n  install(app: App, options: UploadPluginOptions) {\n    const plugin = createUploadPlugin(options);\n    plugin.install!(app);\n  },\n} as Plugin<UploadPluginOptions>;\n","/**\n * useUploadManager - Vue Composable for accessing UploadManager\n *\n * Provides access to the UploadManager instance via Vue's inject API.\n * Must be used within a component that has the Upload Plugin installed.\n *\n * @remarks\n * - Validates: Requirement 10.2 (Vue Composables)\n */\n\nimport { inject } from \"vue\";\nimport type { UploadManager } from \"@chunkflowjs/core\";\nimport { UPLOAD_MANAGER_KEY } from \"./plugin\";\n\n/**\n * Composable for accessing the UploadManager instance\n *\n * Retrieves the UploadManager instance provided by the Upload Plugin.\n * Throws an error if used outside of a component tree with the plugin installed.\n *\n * @returns The UploadManager instance\n * @throws Error if Upload Plugin is not installed\n *\n * @remarks\n * - Validates: Requirement 10.2 (Vue Composables)\n * - Uses Vue's inject API\n * - Validates plugin installation\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useUploadManager } from '@chunkflowjs/upload-client-vue';\n *\n * const manager = useUploadManager();\n *\n * // Use manager to create tasks, etc.\n * const task = manager.createTask(file);\n * </script>\n * ```\n */\nexport function useUploadManager(): UploadManager {\n  const manager = inject<UploadManager>(UPLOAD_MANAGER_KEY);\n\n  if (!manager) {\n    throw new Error(\n      \"useUploadManager must be used within a component tree that has the Upload Plugin installed. \" +\n        \"Make sure you have called app.use(createUploadPlugin({ ... })) in your main.ts file.\",\n    );\n  }\n\n  return manager;\n}\n","/**\n * useUpload - Vue Composable for single file upload\n *\n * Provides a simple interface for uploading a single file with reactive state.\n * Handles task creation, lifecycle events, and state management.\n *\n * @remarks\n * - Validates: Requirement 10.2 (Vue Composables)\n * - Validates: Requirement 10.5 (reactive upload state)\n */\n\nimport { ref, onUnmounted, type Ref } from \"vue\";\nimport type { UploadTask, UploadTaskOptions } from \"@chunkflowjs/core\";\nimport type { UploadStatus, UploadProgress } from \"@chunkflowjs/protocol\";\nimport { useUploadManager } from \"./useUploadManager\";\n\n/**\n * Options for useUpload composable\n */\nexport interface UseUploadOptions extends Partial<UploadTaskOptions> {\n  /** Callback when upload succeeds */\n  onSuccess?: (fileUrl: string) => void;\n  /** Callback when upload fails */\n  onError?: (error: Error) => void;\n  /** Callback on progress updates */\n  onProgress?: (progress: UploadProgress) => void;\n  /** Callback when upload starts */\n  onStart?: () => void;\n  /** Callback when upload is paused */\n  onPause?: () => void;\n  /** Callback when upload is resumed */\n  onResume?: () => void;\n  /** Callback when upload is cancelled */\n  onCancel?: () => void;\n}\n\n/**\n * Return value from useUpload composable\n */\nexport interface UseUploadReturn {\n  /** Function to start uploading a file */\n  upload: (file: File) => void;\n  /** Function to pause the current upload */\n  pause: () => void;\n  /** Function to resume a paused upload */\n  resume: () => void;\n  /** Function to cancel the current upload */\n  cancel: () => void;\n  /** Current upload status (reactive) */\n  status: Ref<UploadStatus>;\n  /** Current upload progress (reactive) */\n  progress: Ref<UploadProgress>;\n  /** Error if upload failed (reactive) */\n  error: Ref<Error | null>;\n  /** The current upload task (reactive, null if no upload in progress) */\n  task: Ref<UploadTask | null>;\n}\n\n/**\n * Composable for uploading a single file\n *\n * Provides reactive state and control functions for file upload.\n * Automatically manages task lifecycle and updates reactive state.\n *\n * @param options - Configuration options and callbacks\n * @returns Upload control functions and reactive state\n *\n * @remarks\n * - Validates: Requirement 10.2 (Vue Composables)\n * - Validates: Requirement 10.5 (reactive state)\n * - Creates new task for each upload\n * - Automatically subscribes to task events\n * - Updates reactive state on events\n * - Cleans up event listeners on unmount\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useUpload } from '@chunkflowjs/upload-client-vue';\n *\n * const { upload, pause, resume, cancel, status, progress, error } = useUpload({\n *   onSuccess: (fileUrl) => {\n *     console.log('Upload complete:', fileUrl);\n *   },\n *   onError: (error) => {\n *     console.error('Upload failed:', error);\n *   },\n *   onProgress: (progress) => {\n *     console.log(`Progress: ${progress.percentage}%`);\n *   },\n * });\n *\n * const handleFileSelect = (event: Event) => {\n *   const input = event.target as HTMLInputElement;\n *   const file = input.files?.[0];\n *   if (file) {\n *     upload(file);\n *   }\n * };\n * </script>\n *\n * <template>\n *   <div>\n *     <input type=\"file\" @change=\"handleFileSelect\" />\n *     <div v-if=\"status === 'uploading'\">\n *       <p>Progress: {{ progress.percentage.toFixed(1) }}%</p>\n *       <p>Speed: {{ (progress.speed / 1024 / 1024).toFixed(2) }} MB/s</p>\n *       <button @click=\"pause\">Pause</button>\n *       <button @click=\"cancel\">Cancel</button>\n *     </div>\n *     <button v-if=\"status === 'paused'\" @click=\"resume\">Resume</button>\n *     <p v-if=\"status === 'success'\">Upload complete!</p>\n *     <p v-if=\"status === 'error'\">Error: {{ error?.message }}</p>\n *   </div>\n * </template>\n * ```\n */\nexport function useUpload(options: UseUploadOptions = {}): UseUploadReturn {\n  const manager = useUploadManager();\n\n  // Reactive state\n  const task = ref<UploadTask | null>(null);\n  const status = ref<UploadStatus>(\"idle\" as UploadStatus);\n  const progress = ref<UploadProgress>({\n    uploadedBytes: 0,\n    totalBytes: 0,\n    percentage: 0,\n    speed: 0,\n    remainingTime: 0,\n    uploadedChunks: 0,\n    totalChunks: 0,\n  });\n  const error = ref<Error | null>(null);\n\n  // Upload function\n  const upload = (file: File) => {\n    // Reset state\n    error.value = null;\n    status.value = \"idle\" as UploadStatus;\n\n    // Create new task\n    const newTask = manager.createTask(file, {\n      chunkSize: options.chunkSize,\n      concurrency: options.concurrency,\n      retryCount: options.retryCount,\n      retryDelay: options.retryDelay,\n      autoStart: false, // We'll start it manually\n    });\n\n    // Set up event listeners\n    newTask.on(\"start\", () => {\n      status.value = \"uploading\" as UploadStatus;\n      options.onStart?.();\n    });\n\n    newTask.on(\"progress\", () => {\n      const progressData = newTask.getProgress();\n      progress.value = progressData;\n      options.onProgress?.(progressData);\n    });\n\n    newTask.on(\"success\", ({ fileUrl }) => {\n      status.value = \"success\" as UploadStatus;\n      options.onSuccess?.(fileUrl);\n    });\n\n    newTask.on(\"error\", ({ error: err }) => {\n      status.value = \"error\" as UploadStatus;\n      error.value = err;\n      options.onError?.(err);\n    });\n\n    newTask.on(\"pause\", () => {\n      status.value = \"paused\" as UploadStatus;\n      options.onPause?.();\n    });\n\n    newTask.on(\"resume\", () => {\n      status.value = \"uploading\" as UploadStatus;\n      options.onResume?.();\n    });\n\n    newTask.on(\"cancel\", () => {\n      status.value = \"cancelled\" as UploadStatus;\n      options.onCancel?.();\n    });\n\n    // Store task reference\n    task.value = newTask;\n\n    // Start upload\n    newTask.start().catch((err) => {\n      console.error(\"Upload failed:\", err);\n    });\n  };\n\n  // Control functions\n  const pause = () => {\n    task.value?.pause();\n  };\n\n  const resume = () => {\n    task.value?.resume().catch((err) => {\n      console.error(\"Resume failed:\", err);\n    });\n  };\n\n  const cancel = () => {\n    task.value?.cancel();\n  };\n\n  // Cleanup on unmount\n  onUnmounted(() => {\n    // Cancel task if still running\n    if (task.value) {\n      const currentStatus = task.value.getStatus();\n      if (currentStatus === \"uploading\" || currentStatus === \"paused\") {\n        task.value.cancel();\n      }\n    }\n  });\n\n  return {\n    upload,\n    pause,\n    resume,\n    cancel,\n    status,\n    progress,\n    error,\n    task,\n  } as UseUploadReturn;\n}\n","/**\n * useUploadList - Vue Composable for managing multiple file uploads\n *\n * Provides reactive state and control functions for managing a list of upload tasks.\n * Automatically syncs with the UploadManager's task list.\n *\n * @remarks\n * - Validates: Requirement 10.2 (Vue Composables)\n * - Validates: Requirement 10.5 (reactive state)\n */\n\nimport { ref, onMounted, onUnmounted, type Ref } from \"vue\";\nimport type { UploadTask } from \"@chunkflowjs/core\";\nimport { useUploadManager } from \"./useUploadManager\";\n\n/**\n * Return value from useUploadList composable\n */\nexport interface UseUploadListReturn {\n  /** Array of all upload tasks (reactive) */\n  tasks: Ref<UploadTask[]>;\n  /** Function to upload multiple files */\n  uploadFiles: (files: File[]) => void;\n  /** Function to pause all running uploads */\n  pauseAll: () => void;\n  /** Function to resume all paused uploads */\n  resumeAll: () => void;\n  /** Function to cancel all uploads */\n  cancelAll: () => void;\n  /** Function to remove a specific task */\n  removeTask: (taskId: string) => void;\n  /** Function to clear all completed tasks */\n  clearCompleted: () => void;\n  /** Function to get task statistics (reactive) */\n  getStatistics: () => {\n    total: number;\n    idle: number;\n    uploading: number;\n    paused: number;\n    success: number;\n    error: number;\n    cancelled: number;\n  };\n}\n\n/**\n * Composable for managing multiple file uploads\n *\n * Provides reactive state for all upload tasks and batch control functions.\n * Automatically updates when tasks are added, removed, or change state.\n *\n * @returns Upload list control functions and reactive state\n *\n * @remarks\n * - Validates: Requirement 10.2 (Vue Composables)\n * - Validates: Requirement 10.5 (reactive state)\n * - Polls manager for task updates (100ms interval)\n * - Provides batch operations for all tasks\n * - Automatically cleans up on unmount\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useUploadList } from '@chunkflowjs/upload-client-vue';\n *\n * const {\n *   tasks,\n *   uploadFiles,\n *   pauseAll,\n *   resumeAll,\n *   cancelAll,\n *   removeTask,\n *   clearCompleted,\n *   getStatistics,\n * } = useUploadList();\n *\n * const handleFilesSelect = (event: Event) => {\n *   const input = event.target as HTMLInputElement;\n *   const files = Array.from(input.files || []);\n *   uploadFiles(files);\n * };\n *\n * const stats = getStatistics();\n * </script>\n *\n * <template>\n *   <div>\n *     <input type=\"file\" multiple @change=\"handleFilesSelect\" />\n *     <div>\n *       <button @click=\"pauseAll\">Pause All</button>\n *       <button @click=\"resumeAll\">Resume All</button>\n *       <button @click=\"cancelAll\">Cancel All</button>\n *       <button @click=\"clearCompleted\">Clear Completed</button>\n *     </div>\n *     <p>\n *       Total: {{ stats.total }} | Uploading: {{ stats.uploading }} |\n *       Success: {{ stats.success }} | Error: {{ stats.error }}\n *     </p>\n *     <ul>\n *       <li v-for=\"task in tasks\" :key=\"task.id\">\n *         <span>{{ task.file.name }}</span>\n *         <span>{{ task.getStatus() }}</span>\n *         <span>{{ task.getProgress().percentage.toFixed(1) }}%</span>\n *         <button @click=\"removeTask(task.id)\">Remove</button>\n *       </li>\n *     </ul>\n *   </div>\n * </template>\n * ```\n */\nexport function useUploadList(): UseUploadListReturn {\n  const manager = useUploadManager();\n\n  // Reactive state for task list\n  const tasks = ref<UploadTask[]>([]);\n\n  // Polling interval ID\n  let intervalId: ReturnType<typeof setInterval> | null = null;\n\n  // Initialize and start polling\n  onMounted(() => {\n    // Initial load\n    tasks.value = manager.getAllTasks();\n\n    // Set up polling interval\n    // We poll every 100ms to catch task updates\n    // This is a simple approach - a more sophisticated solution would use\n    // event subscriptions, but that would require changes to UploadManager\n    intervalId = setInterval(() => {\n      tasks.value = manager.getAllTasks();\n    }, 100);\n  });\n\n  // Cleanup on unmount\n  onUnmounted(() => {\n    if (intervalId !== null) {\n      clearInterval(intervalId);\n      intervalId = null;\n    }\n  });\n\n  // Upload multiple files\n  const uploadFiles = (files: File[]) => {\n    files.forEach((file) => {\n      const task = manager.createTask(file);\n      task.start().catch((error) => {\n        console.error(`Failed to upload ${file.name}:`, error);\n      });\n    });\n  };\n\n  // Pause all running uploads\n  const pauseAll = () => {\n    manager.pauseAll();\n  };\n\n  // Resume all paused uploads\n  const resumeAll = () => {\n    manager.resumeAll().catch((error) => {\n      console.error(\"Failed to resume all uploads:\", error);\n    });\n  };\n\n  // Cancel all uploads\n  const cancelAll = () => {\n    manager.cancelAll();\n  };\n\n  // Remove a specific task\n  const removeTask = (taskId: string) => {\n    manager.deleteTask(taskId).catch((error) => {\n      console.error(`Failed to remove task ${taskId}:`, error);\n    });\n  };\n\n  // Clear all completed tasks\n  const clearCompleted = () => {\n    manager.clearCompletedTasks().catch((error) => {\n      console.error(\"Failed to clear completed tasks:\", error);\n    });\n  };\n\n  // Get task statistics\n  const getStatistics = () => {\n    return manager.getStatistics();\n  };\n\n  return {\n    tasks,\n    uploadFiles,\n    pauseAll,\n    resumeAll,\n    cancelAll,\n    removeTask,\n    clearCompleted,\n    getStatistics,\n  } as UseUploadListReturn;\n}\n"],"mappings":";;;;;;;;;;AAsBA,MAAa,qBAAqB,OAAO,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDzD,SAAgB,mBAAmB,SAAsC;CACvE,MAAM,EAAE,gBAAgB,mBAAmB;AAiC3C,QA9BuB,EACrB,QAAQ,KAAU;EAEhB,MAAM,UAAU,IAAI,cAAc;GAChC;GACA,GAAG;GACJ,CAAC;AAIF,MAAI,QAAQ,oBAAoB,QAAQ;AAIxC,UAAQ,MAAM,CAAC,OAAO,UAAU;AAC9B,WAAQ,MAAM,uCAAuC,MAAM;IAC3D;EAMF,MAAM,kBAAkB,IAAI,QAAQ,KAAK,IAAI;AAC7C,MAAI,gBAAgB;AAClB,WAAQ,OAAO;AACf,oBAAiB;;IAGtB;;;;;;;;;;;AAcH,qBAAe,EACb,QAAQ,KAAU,SAA8B;AAE9C,CADe,mBAAmB,QAAQ,CACnC,QAAS,IAAI;GAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACjFD,SAAgB,mBAAkC;CAChD,MAAM,UAAU,OAAsB,mBAAmB;AAEzD,KAAI,CAAC,QACH,OAAM,IAAI,MACR,mLAED;AAGH,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACmET,SAAgB,UAAU,UAA4B,EAAE,EAAmB;CACzE,MAAM,UAAU,kBAAkB;CAGlC,MAAM,OAAO,IAAuB,KAAK;CACzC,MAAM,SAAS,IAAkB,OAAuB;CACxD,MAAM,WAAW,IAAoB;EACnC,eAAe;EACf,YAAY;EACZ,YAAY;EACZ,OAAO;EACP,eAAe;EACf,gBAAgB;EAChB,aAAa;EACd,CAAC;CACF,MAAM,QAAQ,IAAkB,KAAK;CAGrC,MAAM,UAAU,SAAe;AAE7B,QAAM,QAAQ;AACd,SAAO,QAAQ;EAGf,MAAM,UAAU,QAAQ,WAAW,MAAM;GACvC,WAAW,QAAQ;GACnB,aAAa,QAAQ;GACrB,YAAY,QAAQ;GACpB,YAAY,QAAQ;GACpB,WAAW;GACZ,CAAC;AAGF,UAAQ,GAAG,eAAe;AACxB,UAAO,QAAQ;AACf,WAAQ,WAAW;IACnB;AAEF,UAAQ,GAAG,kBAAkB;GAC3B,MAAM,eAAe,QAAQ,aAAa;AAC1C,YAAS,QAAQ;AACjB,WAAQ,aAAa,aAAa;IAClC;AAEF,UAAQ,GAAG,YAAY,EAAE,cAAc;AACrC,UAAO,QAAQ;AACf,WAAQ,YAAY,QAAQ;IAC5B;AAEF,UAAQ,GAAG,UAAU,EAAE,OAAO,UAAU;AACtC,UAAO,QAAQ;AACf,SAAM,QAAQ;AACd,WAAQ,UAAU,IAAI;IACtB;AAEF,UAAQ,GAAG,eAAe;AACxB,UAAO,QAAQ;AACf,WAAQ,WAAW;IACnB;AAEF,UAAQ,GAAG,gBAAgB;AACzB,UAAO,QAAQ;AACf,WAAQ,YAAY;IACpB;AAEF,UAAQ,GAAG,gBAAgB;AACzB,UAAO,QAAQ;AACf,WAAQ,YAAY;IACpB;AAGF,OAAK,QAAQ;AAGb,UAAQ,OAAO,CAAC,OAAO,QAAQ;AAC7B,WAAQ,MAAM,kBAAkB,IAAI;IACpC;;CAIJ,MAAM,cAAc;AAClB,OAAK,OAAO,OAAO;;CAGrB,MAAM,eAAe;AACnB,OAAK,OAAO,QAAQ,CAAC,OAAO,QAAQ;AAClC,WAAQ,MAAM,kBAAkB,IAAI;IACpC;;CAGJ,MAAM,eAAe;AACnB,OAAK,OAAO,QAAQ;;AAItB,mBAAkB;AAEhB,MAAI,KAAK,OAAO;GACd,MAAM,gBAAgB,KAAK,MAAM,WAAW;AAC5C,OAAI,kBAAkB,eAAe,kBAAkB,SACrD,MAAK,MAAM,QAAQ;;GAGvB;AAEF,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzHH,SAAgB,gBAAqC;CACnD,MAAM,UAAU,kBAAkB;CAGlC,MAAM,QAAQ,IAAkB,EAAE,CAAC;CAGnC,IAAI,aAAoD;AAGxD,iBAAgB;AAEd,QAAM,QAAQ,QAAQ,aAAa;AAMnC,eAAa,kBAAkB;AAC7B,SAAM,QAAQ,QAAQ,aAAa;KAClC,IAAI;GACP;AAGF,mBAAkB;AAChB,MAAI,eAAe,MAAM;AACvB,iBAAc,WAAW;AACzB,gBAAa;;GAEf;CAGF,MAAM,eAAe,UAAkB;AACrC,QAAM,SAAS,SAAS;AAEtB,GADa,QAAQ,WAAW,KAAK,CAChC,OAAO,CAAC,OAAO,UAAU;AAC5B,YAAQ,MAAM,oBAAoB,KAAK,KAAK,IAAI,MAAM;KACtD;IACF;;CAIJ,MAAM,iBAAiB;AACrB,UAAQ,UAAU;;CAIpB,MAAM,kBAAkB;AACtB,UAAQ,WAAW,CAAC,OAAO,UAAU;AACnC,WAAQ,MAAM,iCAAiC,MAAM;IACrD;;CAIJ,MAAM,kBAAkB;AACtB,UAAQ,WAAW;;CAIrB,MAAM,cAAc,WAAmB;AACrC,UAAQ,WAAW,OAAO,CAAC,OAAO,UAAU;AAC1C,WAAQ,MAAM,yBAAyB,OAAO,IAAI,MAAM;IACxD;;CAIJ,MAAM,uBAAuB;AAC3B,UAAQ,qBAAqB,CAAC,OAAO,UAAU;AAC7C,WAAQ,MAAM,oCAAoC,MAAM;IACxD;;CAIJ,MAAM,sBAAsB;AAC1B,SAAO,QAAQ,eAAe;;AAGhC,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@chunkflowjs/upload-client-vue",
+  "version": "0.0.1-alpha.1",
+  "description": "Vue adapter for ChunkFlow Upload SDK",
+  "keywords": [
+    "composables",
+    "typescript",
+    "upload",
+    "vue"
+  ],
+  "license": "MIT",
+  "author": "",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm --dts",
+    "dev": "tsdown src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@chunkflowjs/core": "workspace:*",
+    "@chunkflowjs/protocol": "workspace:*"
+  },
+  "devDependencies": {
+    "@vue/test-utils": "^2.4.6",
+    "happy-dom": "^20.4.0",
+    "tsdown": "^0.20.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18",
+    "vue": "^3.5.27"
+  },
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  }
+}