vue-reactive-queue 0.0.0

package/README.md

@@ -0,0 +1,276 @@
+# vue-reactive-queue
+
+Reactive async task queue for Vue 3 with concurrency control.
+
+## Features
+
+- 🚀 **Concurrency Control** - Limit parallel task execution
+- 📊 **Reactive State** - Track task status in real-time with Vue reactivity
+- ⏸️ **Pause/Resume** - Control queue execution flow
+- 🔄 **Retry** - Retry failed tasks with one call
+- 📝 **Task History** - Keep track of completed tasks
+- 🎯 **Manual Execution** - Start specific tasks on demand
+- 💪 **TypeScript** - Full type support with generics
+
+## Install
+
+```bash
+npm install vue-reactive-queue
+```
+
+## Usage
+
+### Basic
+
+```ts
+import { useQueue } from 'vue-reactive-queue'
+
+const queue = useQueue()
+
+// Add tasks to the queue
+queue.add(async () => {
+  await processFile('document.pdf')
+})
+
+queue.add(async () => {
+  await processFile('image.png')
+})
+```
+
+### Concurrency Control
+
+```ts
+const queue = useQueue({ concurrency: 3 })
+
+// Only 3 tasks will run in parallel
+queue.add(() => fetchUser(1))
+queue.add(() => fetchUser(2))
+queue.add(() => fetchUser(3))
+queue.add(() => fetchUser(4)) // waits for a slot
+```
+
+### Reactive State
+
+```vue
+<script setup>
+import { useQueue } from 'vue-reactive-queue'
+
+const queue = useQueue({ concurrency: 2 })
+
+function addTask() {
+  queue.add(async () => {
+    await new Promise(r => setTimeout(r, 1000))
+    return 'done'
+  })
+}
+</script>
+
+<template>
+  <div>
+    <p>Pending: {{ queue.stats.value.pending }}</p>
+    <p>Running: {{ queue.stats.value.running }}</p>
+    <p>Completed: {{ queue.stats.value.completed }}</p>
+
+    <button @click="addTask">Add Task</button>
+
+    <div v-for="task in queue.tasks.value" :key="task.id">
+      <span>Task #{{ task.id }}: {{ task.status }}</span>
+      <button v-if="task.status === 'rejected'" @click="queue.retry(task.id)">
+        Retry
+      </button>
+    </div>
+  </div>
+</template>
+```
+
+### Pause and Resume
+
+```ts
+const queue = useQueue()
+
+queue.add(() => task1())
+queue.add(() => task2())
+
+queue.pause()  // Stop executing new tasks
+queue.resume() // Continue execution
+```
+
+### Start Paused
+
+```ts
+const queue = useQueue({ immediate: false })
+
+queue.add(() => task1())
+queue.add(() => task2())
+
+// Tasks are pending, not running
+console.log(queue.stats.value.isPaused) // true
+
+// Start when ready
+queue.resume()
+```
+
+### Manual Task Execution
+
+Start a specific task immediately, ignoring the pause state:
+
+```ts
+const queue = useQueue({ immediate: false })
+
+const { id: idA } = queue.add(() => taskA())
+const { id: idB } = queue.add(() => taskB())
+const { id: idC } = queue.add(() => taskC())
+
+// Only execute taskB, leave others pending
+await queue.start(idB)
+```
+
+### Retry Failed Tasks
+
+```ts
+const queue = useQueue()
+
+const { id } = queue.add(async () => {
+  await uploadFile(file) // might fail due to network issues
+})
+
+// Later, if the task failed
+const result = queue.retry(id)
+if (result.success) {
+  await result.promise
+}
+```
+
+### Task Metadata
+
+Attach custom data to tasks for UI rendering:
+
+```ts
+interface TaskMeta {
+  filename: string
+  size: number
+}
+
+const queue = useQueue<TaskMeta>()
+
+queue.add(
+  () => uploadFile(file),
+  { filename: file.name, size: file.size }
+)
+```
+
+```vue
+<template>
+  <div v-for="task in queue.tasks.value" :key="task.id">
+    <span>{{ task.meta?.filename }}</span>
+    <span>{{ task.status }}</span>
+  </div>
+</template>
+```
+
+### Callbacks
+
+```ts
+const queue = useQueue({
+  onSuccess(task) {
+    console.log('Task completed:', task.result)
+  },
+  onError(task, error) {
+    console.error('Task failed:', error)
+  },
+  onFinished() {
+    console.log('All tasks done!')
+  },
+})
+```
+
+### Limit History
+
+```ts
+// Only keep the last 10 completed tasks
+const queue = useQueue({ maxHistory: 10 })
+
+// Keep no history (only pending/running tasks visible)
+const queue = useQueue({ maxHistory: 0 })
+```
+
+### Wait for Idle
+
+```ts
+const queue = useQueue()
+
+queue.add(() => task1())
+queue.add(() => task2())
+queue.add(() => task3())
+
+await queue.waitForIdle()
+console.log('All tasks completed!')
+```
+
+### Dynamic Concurrency
+
+```ts
+import { ref } from 'vue'
+
+const limit = ref(2)
+const queue = useQueue({ concurrency: limit })
+
+// Reactively update concurrency
+limit.value = 5
+
+// Or use setConcurrency
+queue.setConcurrency(10)
+```
+
+## Type Declarations
+
+```ts
+export interface QueueTask<T = unknown, M = unknown> {
+  readonly id: number
+  status: 'pending' | 'running' | 'fulfilled' | 'rejected'
+  readonly createdAt: number
+  startedAt?: number
+  finishedAt?: number
+  result?: T
+  error?: unknown
+  readonly meta?: M
+}
+
+export interface QueueStats {
+  readonly pending: number
+  readonly running: number
+  readonly completed: number
+  readonly failed: number
+  readonly total: number
+  readonly isIdle: boolean
+  readonly isPaused: boolean
+}
+
+export interface UseQueueOptions<M = unknown> {
+  concurrency?: MaybeRefOrGetter<number>  // default: 1
+  immediate?: boolean                      // default: true
+  maxHistory?: number                      // default: undefined (keep all)
+  onSuccess?: (task: QueueTask<unknown, M>) => void
+  onError?: (task: QueueTask<unknown, M>, error: unknown) => void
+  onFinished?: () => void
+}
+
+export interface UseQueueReturn<M = unknown> {
+  tasks: Readonly<ShallowRef<QueueTask<unknown, M>[]>>
+  stats: ComputedRef<QueueStats>
+  concurrency: Readonly<ShallowRef<number>>
+  add: <T>(fn: () => T | Promise<T>, meta?: M) => { id: number; task: QueueTask<T, M>; promise: Promise<T> }
+  start: (id: number) => Promise<unknown> | undefined
+  retry: (id: number) => RetryResult
+  remove: (id: number) => boolean
+  clear: () => void
+  pause: () => void
+  resume: () => void
+  setConcurrency: (value: number) => void
+  waitForIdle: () => Promise<void>
+}
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,128 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/index.d.ts
+type TaskStatus = "pending" | "running" | "fulfilled" | "rejected";
+type TaskFunction<T = unknown> = () => T | Promise<T>;
+interface QueueTask<T = unknown, M = unknown> {
+  readonly id: number;
+  status: TaskStatus;
+  readonly createdAt: number;
+  startedAt?: number;
+  finishedAt?: number;
+  result?: T;
+  error?: unknown;
+  readonly run: TaskFunction<T>;
+  readonly meta?: M;
+}
+interface QueueStats {
+  readonly pending: number;
+  readonly running: number;
+  readonly completed: number;
+  readonly failed: number;
+  readonly total: number;
+  readonly isIdle: boolean;
+  readonly isPaused: boolean;
+}
+interface UseQueueOptions<M = unknown> {
+  /**
+   * Maximum number of concurrent tasks
+   *
+   * @default 1
+   */
+  concurrency?: MaybeRefOrGetter<number>;
+  /**
+   * Start the queue immediately
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * Maximum number of completed tasks to keep in history
+   * Set to 0 to keep no history, undefined to keep all
+   *
+   * @default undefined
+   */
+  maxHistory?: number;
+  /**
+   * Callback when a task completes successfully
+   */
+  onSuccess?: (task: QueueTask<unknown, M>) => void;
+  /**
+   * Callback when a task fails
+   */
+  onError?: (task: QueueTask<unknown, M>, error: unknown) => void;
+  /**
+   * Callback when all tasks are finished and queue becomes idle
+   */
+  onFinished?: () => void;
+}
+type RetryResult = {
+  success: true;
+  promise: Promise<unknown>;
+} | {
+  success: false;
+  reason: "not-found" | "not-rejected" | "already-queued";
+};
+interface UseQueueReturn<M = unknown> {
+  /**
+   * All tasks in the queue (including history)
+   */
+  tasks: Readonly<ShallowRef<QueueTask<unknown, M>[]>>;
+  /**
+   * Queue statistics
+   */
+  stats: ComputedRef<QueueStats>;
+  /**
+   * Current concurrency limit
+   */
+  concurrency: Readonly<ShallowRef<number>>;
+  /**
+   * Add a task to the queue
+   */
+  add: <T = unknown>(fn: TaskFunction<T>, meta?: M) => {
+    id: number;
+    task: QueueTask<T, M>;
+    promise: Promise<T>;
+  };
+  /**
+   * Start a specific pending task immediately (ignores pause state)
+   */
+  start: (id: number) => Promise<unknown> | undefined;
+  /**
+   * Retry a failed task
+   */
+  retry: (id: number) => RetryResult;
+  /**
+   * Remove a pending task from the queue
+   */
+  remove: (id: number) => boolean;
+  /**
+   * Clear all pending tasks
+   */
+  clear: () => void;
+  /**
+   * Pause the queue (running tasks will continue)
+   */
+  pause: () => void;
+  /**
+   * Resume the queue
+   */
+  resume: () => void;
+  /**
+   * Set the concurrency limit
+   */
+  setConcurrency: (value: number) => void;
+  /**
+   * Wait for the queue to become idle
+   */
+  waitForIdle: () => Promise<void>;
+}
+/**
+ * Reactive async task queue with concurrency control.
+ *
+ * @see https://github.com/ruibaby/vue-reactive-queue
+ */
+declare function useQueue<M = unknown>(options?: UseQueueOptions<M>): UseQueueReturn<M>;
+//#endregion
+export { type MaybeRefOrGetter, QueueStats, QueueTask, RetryResult, TaskFunction, TaskStatus, UseQueueOptions, UseQueueReturn, useQueue };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;KAcY,UAAA;AAAA,KAEA,YAAA,sBAAkC,CAAA,GAAI,OAAA,CAAQ,CAAA;AAAA,UAEzC,SAAA;EAAA,SACN,EAAA;EACT,MAAA,EAAQ,UAAA;EAAA,SACC,SAAA;EACT,SAAA;EACA,UAAA;EACA,MAAA,GAAS,CAAA;EACT,KAAA;EAAA,SACS,GAAA,EAAK,YAAA,CAAa,CAAA;EAAA,SAClB,IAAA,GAAO,CAAA;AAAA;AAAA,UAGD,UAAA;EAAA,SACN,OAAA;EAAA,SACA,OAAA;EAAA,SACA,SAAA;EAAA,SACA,MAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA;AAAA;AAAA,UAGM,eAAA;EAtBS;;;;;EA4BxB,WAAA,GAAc,gBAAA;EAnBG;;;;;EA0BjB,SAAA;EAjCQ;;;;;;EAyCR,UAAA;EAnCS;;;EAwCT,SAAA,IAAa,IAAA,EAAM,SAAA,UAAmB,CAAA;EAvCtB;;;EA4ChB,OAAA,IAAW,IAAA,EAAM,SAAA,UAAmB,CAAA,GAAI,KAAA;EAzCf;;;EA8CzB,UAAA;AAAA;AAAA,KAGU,WAAA;EACN,OAAA;EAAe,OAAA,EAAS,OAAA;AAAA;EACxB,OAAA;EAAgB,MAAA;AAAA;AAAA,UAEL,cAAA;EA3Ce;;;EA+C9B,KAAA,EAAO,QAAA,CAAS,UAAA,CAAW,SAAA,UAAmB,CAAA;EArB3B;;;EA0BnB,KAAA,EAAO,WAAA,CAAY,UAAA;EArBO;;;EA0B1B,WAAA,EAAa,QAAA,CAAS,UAAA;EA5CtB;;;EAiDA,GAAA,gBACE,EAAA,EAAI,YAAA,CAAa,CAAA,GACjB,IAAA,GAAO,CAAA;IAEP,EAAA;IACA,IAAA,EAAM,SAAA,CAAU,CAAA,EAAG,CAAA;IACnB,OAAA,EAAS,OAAA,CAAQ,CAAA;EAAA;EArCiB;;;EA2CpC,KAAA,GAAQ,EAAA,aAAe,OAAA;EAtCb;;AAGZ;EAwCE,KAAA,GAAQ,EAAA,aAAe,WAAA;;;;EAKvB,MAAA,GAAS,EAAA;EA5CmB;;;EAiD5B,KAAA;EAhD0B;AAE5B;;EAmDE,KAAA;EA/C8C;;;EAoD9C,MAAA;EA/CmB;;;EAoDnB,cAAA,GAAiB,KAAA;EAzCE;;;EA8CnB,WAAA,QAAmB,OAAA;AAAA;;;;;;iBAiCL,QAAA,aAAA,CACd,OAAA,GAAS,eAAA,CAAgB,CAAA,IACxB,cAAA,CAAe,CAAA"}

package/dist/index.mjs

@@ -0,0 +1,290 @@
+import { computed, shallowReadonly, shallowRef, toValue, triggerRef, watch } from "vue";
+
+//#region src/index.ts
+function clampConcurrency(value) {
+	if (!Number.isFinite(value)) return 1;
+	return Math.max(1, Math.floor(value));
+}
+function createDeferred() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+/**
+* Reactive async task queue with concurrency control.
+*
+* @see https://github.com/ruibaby/vue-reactive-queue
+*/
+function useQueue(options = {}) {
+	const { concurrency: initialConcurrency = 1, immediate = true, maxHistory, onSuccess, onError, onFinished } = options;
+	const concurrency = shallowRef(clampConcurrency(toValue(initialConcurrency)));
+	const isPaused = shallowRef(!immediate);
+	const tasks = shallowRef([]);
+	const pendingQueue = shallowRef([]);
+	const deferredMap = /* @__PURE__ */ new Map();
+	let taskId = 0;
+	const runningCount = shallowRef(0);
+	const pendingCount = shallowRef(0);
+	const completedCount = shallowRef(0);
+	const failedCount = shallowRef(0);
+	const stats = computed(() => ({
+		pending: pendingCount.value,
+		running: runningCount.value,
+		completed: completedCount.value,
+		failed: failedCount.value,
+		total: tasks.value.length,
+		isPaused: isPaused.value,
+		isIdle: pendingCount.value === 0 && runningCount.value === 0
+	}));
+	function touchTasks() {
+		triggerRef(tasks);
+	}
+	function touchQueue() {
+		triggerRef(pendingQueue);
+	}
+	function trimHistory() {
+		if (maxHistory === void 0 || maxHistory < 0) return;
+		const completedTasks = tasks.value.filter((t) => t.status === "fulfilled" || t.status === "rejected");
+		if (completedTasks.length <= maxHistory) return;
+		const toRemove = completedTasks.length - maxHistory;
+		const idsToRemove = new Set(completedTasks.slice(0, toRemove).map((t) => t.id));
+		tasks.value = tasks.value.filter((t) => !idsToRemove.has(t.id));
+		touchTasks();
+	}
+	function checkIdle() {
+		if (stats.value.isIdle) onFinished?.();
+	}
+	function executeTask(task, deferred) {
+		runningCount.value += 1;
+		task.status = "running";
+		task.startedAt = Date.now();
+		touchTasks();
+		let runPromise;
+		try {
+			runPromise = Promise.resolve(task.run());
+		} catch (error) {
+			runPromise = Promise.reject(error);
+		}
+		runPromise.then((result) => {
+			task.status = "fulfilled";
+			task.result = result;
+			task.finishedAt = Date.now();
+			completedCount.value += 1;
+			runningCount.value -= 1;
+			touchTasks();
+			trimHistory();
+			deferred?.resolve(result);
+			onSuccess?.(task);
+			checkIdle();
+		}).catch((error) => {
+			task.status = "rejected";
+			task.error = error;
+			task.finishedAt = Date.now();
+			failedCount.value += 1;
+			runningCount.value -= 1;
+			touchTasks();
+			trimHistory();
+			deferred?.reject(error);
+			onError?.(task, error);
+			checkIdle();
+		}).finally(() => {
+			deferredMap.delete(task.id);
+			schedule();
+		});
+	}
+	function schedule() {
+		if (isPaused.value) return;
+		while (runningCount.value < concurrency.value && pendingQueue.value.length > 0) {
+			const nextTask = pendingQueue.value.shift();
+			touchQueue();
+			if (!nextTask) break;
+			if (nextTask.status === "pending") pendingCount.value -= 1;
+			executeTask(nextTask, deferredMap.get(nextTask.id));
+		}
+	}
+	function add(fn, meta) {
+		const id = ++taskId;
+		const task = {
+			id,
+			status: "pending",
+			createdAt: Date.now(),
+			run: fn,
+			meta
+		};
+		tasks.value.push(task);
+		triggerRef(tasks);
+		pendingQueue.value.push(task);
+		triggerRef(pendingQueue);
+		pendingCount.value += 1;
+		const deferred = createDeferred();
+		deferredMap.set(id, deferred);
+		schedule();
+		return {
+			id,
+			task,
+			promise: deferred.promise
+		};
+	}
+	function start(id) {
+		const task = tasks.value.find((t) => t.id === id);
+		if (!task || task.status !== "pending") return void 0;
+		const queueIndex = pendingQueue.value.findIndex((t) => t.id === id);
+		if (queueIndex !== -1) {
+			pendingQueue.value.splice(queueIndex, 1);
+			touchQueue();
+		}
+		const existingDeferred = deferredMap.get(id);
+		deferredMap.delete(id);
+		pendingCount.value -= 1;
+		const deferred = createDeferred();
+		let runPromise;
+		try {
+			runPromise = Promise.resolve(task.run());
+		} catch (error) {
+			runPromise = Promise.reject(error);
+		}
+		runningCount.value += 1;
+		task.status = "running";
+		task.startedAt = Date.now();
+		touchTasks();
+		runPromise.then((result) => {
+			task.status = "fulfilled";
+			task.result = result;
+			task.finishedAt = Date.now();
+			completedCount.value += 1;
+			runningCount.value -= 1;
+			touchTasks();
+			trimHistory();
+			deferred.resolve(result);
+			existingDeferred?.resolve(result);
+			onSuccess?.(task);
+			checkIdle();
+		}).catch((error) => {
+			task.status = "rejected";
+			task.error = error;
+			task.finishedAt = Date.now();
+			failedCount.value += 1;
+			runningCount.value -= 1;
+			touchTasks();
+			trimHistory();
+			deferred.reject(error);
+			existingDeferred?.reject(error);
+			onError?.(task, error);
+			checkIdle();
+		});
+		return deferred.promise;
+	}
+	function retry(id) {
+		const task = tasks.value.find((t) => t.id === id);
+		if (!task) return {
+			success: false,
+			reason: "not-found"
+		};
+		if (task.status !== "rejected") return {
+			success: false,
+			reason: "not-rejected"
+		};
+		if (pendingQueue.value.some((t) => t.id === id)) return {
+			success: false,
+			reason: "already-queued"
+		};
+		failedCount.value -= 1;
+		pendingCount.value += 1;
+		task.status = "pending";
+		task.startedAt = void 0;
+		task.finishedAt = void 0;
+		task.result = void 0;
+		task.error = void 0;
+		touchTasks();
+		const deferred = createDeferred();
+		deferredMap.set(id, deferred);
+		pendingQueue.value.push(task);
+		triggerRef(pendingQueue);
+		schedule();
+		return {
+			success: true,
+			promise: deferred.promise
+		};
+	}
+	function remove(id) {
+		const queueIndex = pendingQueue.value.findIndex((t) => t.id === id);
+		if (queueIndex === -1) return false;
+		pendingQueue.value.splice(queueIndex, 1);
+		touchQueue();
+		const taskIndex = tasks.value.findIndex((t) => t.id === id);
+		if (taskIndex !== -1) {
+			tasks.value.splice(taskIndex, 1);
+			touchTasks();
+		}
+		pendingCount.value -= 1;
+		deferredMap.get(id)?.reject(/* @__PURE__ */ new Error("Task removed"));
+		deferredMap.delete(id);
+		return true;
+	}
+	function clear() {
+		if (pendingQueue.value.length === 0) return;
+		const pendingIds = new Set(pendingQueue.value.map((t) => t.id));
+		const clearedCount = pendingIds.size;
+		pendingQueue.value = [];
+		triggerRef(pendingQueue);
+		tasks.value = tasks.value.filter((t) => !pendingIds.has(t.id));
+		triggerRef(tasks);
+		pendingCount.value -= clearedCount;
+		for (const id of pendingIds) {
+			deferredMap.get(id)?.reject(/* @__PURE__ */ new Error("Queue cleared"));
+			deferredMap.delete(id);
+		}
+	}
+	function pause() {
+		isPaused.value = true;
+	}
+	function resume() {
+		if (!isPaused.value) return;
+		isPaused.value = false;
+		schedule();
+	}
+	function setConcurrency(value) {
+		concurrency.value = clampConcurrency(value);
+		schedule();
+	}
+	function waitForIdle() {
+		if (stats.value.isIdle) return Promise.resolve();
+		return new Promise((resolve) => {
+			const stop = watch(() => stats.value.isIdle, (idle) => {
+				if (idle) {
+					stop();
+					resolve();
+				}
+			});
+		});
+	}
+	if (typeof initialConcurrency === "function" || typeof initialConcurrency === "object") watch(() => toValue(initialConcurrency), (value) => {
+		concurrency.value = clampConcurrency(value);
+		schedule();
+	});
+	return {
+		tasks: shallowReadonly(tasks),
+		stats,
+		concurrency: shallowReadonly(concurrency),
+		add,
+		start,
+		retry,
+		remove,
+		clear,
+		pause,
+		resume,
+		setConcurrency,
+		waitForIdle
+	};
+}
+
+//#endregion
+export { useQueue };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { ComputedRef, MaybeRefOrGetter, ShallowRef } from \"vue\";\nimport {\n  computed,\n  shallowReadonly,\n  shallowRef,\n  toValue,\n  triggerRef,\n  watch,\n} from \"vue\";\n\n// =====================\n// Types\n// =====================\n\nexport type TaskStatus = \"pending\" | \"running\" | \"fulfilled\" | \"rejected\";\n\nexport type TaskFunction<T = unknown> = () => T | Promise<T>;\n\nexport interface QueueTask<T = unknown, M = unknown> {\n  readonly id: number;\n  status: TaskStatus;\n  readonly createdAt: number;\n  startedAt?: number;\n  finishedAt?: number;\n  result?: T;\n  error?: unknown;\n  readonly run: TaskFunction<T>;\n  readonly meta?: M;\n}\n\nexport interface QueueStats {\n  readonly pending: number;\n  readonly running: number;\n  readonly completed: number;\n  readonly failed: number;\n  readonly total: number;\n  readonly isIdle: boolean;\n  readonly isPaused: boolean;\n}\n\nexport interface UseQueueOptions<M = unknown> {\n  /**\n   * Maximum number of concurrent tasks\n   *\n   * @default 1\n   */\n  concurrency?: MaybeRefOrGetter<number>;\n\n  /**\n   * Start the queue immediately\n   *\n   * @default true\n   */\n  immediate?: boolean;\n\n  /**\n   * Maximum number of completed tasks to keep in history\n   * Set to 0 to keep no history, undefined to keep all\n   *\n   * @default undefined\n   */\n  maxHistory?: number;\n\n  /**\n   * Callback when a task completes successfully\n   */\n  onSuccess?: (task: QueueTask<unknown, M>) => void;\n\n  /**\n   * Callback when a task fails\n   */\n  onError?: (task: QueueTask<unknown, M>, error: unknown) => void;\n\n  /**\n   * Callback when all tasks are finished and queue becomes idle\n   */\n  onFinished?: () => void;\n}\n\nexport type RetryResult =\n  | { success: true; promise: Promise<unknown> }\n  | { success: false; reason: \"not-found\" | \"not-rejected\" | \"already-queued\" };\n\nexport interface UseQueueReturn<M = unknown> {\n  /**\n   * All tasks in the queue (including history)\n   */\n  tasks: Readonly<ShallowRef<QueueTask<unknown, M>[]>>;\n\n  /**\n   * Queue statistics\n   */\n  stats: ComputedRef<QueueStats>;\n\n  /**\n   * Current concurrency limit\n   */\n  concurrency: Readonly<ShallowRef<number>>;\n\n  /**\n   * Add a task to the queue\n   */\n  add: <T = unknown>(\n    fn: TaskFunction<T>,\n    meta?: M,\n  ) => {\n    id: number;\n    task: QueueTask<T, M>;\n    promise: Promise<T>;\n  };\n\n  /**\n   * Start a specific pending task immediately (ignores pause state)\n   */\n  start: (id: number) => Promise<unknown> | undefined;\n\n  /**\n   * Retry a failed task\n   */\n  retry: (id: number) => RetryResult;\n\n  /**\n   * Remove a pending task from the queue\n   */\n  remove: (id: number) => boolean;\n\n  /**\n   * Clear all pending tasks\n   */\n  clear: () => void;\n\n  /**\n   * Pause the queue (running tasks will continue)\n   */\n  pause: () => void;\n\n  /**\n   * Resume the queue\n   */\n  resume: () => void;\n\n  /**\n   * Set the concurrency limit\n   */\n  setConcurrency: (value: number) => void;\n\n  /**\n   * Wait for the queue to become idle\n   */\n  waitForIdle: () => Promise<void>;\n}\n\n// =====================\n// Implementation\n// =====================\n\ninterface Deferred<T> {\n  resolve: (value: T) => void;\n  reject: (reason?: unknown) => void;\n  promise: Promise<T>;\n}\n\nfunction clampConcurrency(value: number): number {\n  if (!Number.isFinite(value)) return 1;\n  return Math.max(1, Math.floor(value));\n}\n\nfunction createDeferred<T>(): Deferred<T> {\n  let resolve: (value: T) => void;\n  let reject: (reason?: unknown) => void;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n  return { promise, resolve: resolve!, reject: reject! };\n}\n\n/**\n * Reactive async task queue with concurrency control.\n *\n * @see https://github.com/ruibaby/vue-reactive-queue\n */\nexport function useQueue<M = unknown>(\n  options: UseQueueOptions<M> = {},\n): UseQueueReturn<M> {\n  const {\n    concurrency: initialConcurrency = 1,\n    immediate = true,\n    maxHistory,\n    onSuccess,\n    onError,\n    onFinished,\n  } = options;\n\n  const concurrency = shallowRef(clampConcurrency(toValue(initialConcurrency)));\n  const isPaused = shallowRef(!immediate);\n  const tasks = shallowRef<QueueTask<unknown, M>[]>([]);\n  const pendingQueue = shallowRef<QueueTask<unknown, M>[]>([]);\n  const deferredMap = new Map<number, Deferred<unknown>>();\n\n  let taskId = 0;\n  const runningCount = shallowRef(0);\n  const pendingCount = shallowRef(0);\n  const completedCount = shallowRef(0);\n  const failedCount = shallowRef(0);\n\n  const stats = computed<QueueStats>(() => ({\n    pending: pendingCount.value,\n    running: runningCount.value,\n    completed: completedCount.value,\n    failed: failedCount.value,\n    total: tasks.value.length,\n    isPaused: isPaused.value,\n    isIdle: pendingCount.value === 0 && runningCount.value === 0,\n  }));\n\n  function touchTasks() {\n    triggerRef(tasks);\n  }\n\n  function touchQueue() {\n    triggerRef(pendingQueue);\n  }\n\n  function trimHistory() {\n    if (maxHistory === undefined || maxHistory < 0) return;\n\n    const completedTasks = tasks.value.filter(\n      (t) => t.status === \"fulfilled\" || t.status === \"rejected\",\n    );\n    if (completedTasks.length <= maxHistory) return;\n\n    const toRemove = completedTasks.length - maxHistory;\n    const idsToRemove = new Set(\n      completedTasks.slice(0, toRemove).map((t) => t.id),\n    );\n    tasks.value = tasks.value.filter((t) => !idsToRemove.has(t.id));\n    touchTasks();\n  }\n\n  function checkIdle() {\n    if (stats.value.isIdle) onFinished?.();\n  }\n\n  function executeTask(\n    task: QueueTask<unknown, M>,\n    deferred?: Deferred<unknown>,\n  ) {\n    runningCount.value += 1;\n    task.status = \"running\";\n    task.startedAt = Date.now();\n    touchTasks();\n\n    let runPromise: Promise<unknown>;\n    try {\n      runPromise = Promise.resolve(task.run());\n    } catch (error) {\n      runPromise = Promise.reject(error);\n    }\n\n    runPromise\n      .then((result) => {\n        task.status = \"fulfilled\";\n        task.result = result;\n        task.finishedAt = Date.now();\n        completedCount.value += 1;\n        runningCount.value -= 1;\n        touchTasks();\n        trimHistory();\n        deferred?.resolve(result);\n        onSuccess?.(task);\n        checkIdle();\n      })\n      .catch((error) => {\n        task.status = \"rejected\";\n        task.error = error;\n        task.finishedAt = Date.now();\n        failedCount.value += 1;\n        runningCount.value -= 1;\n        touchTasks();\n        trimHistory();\n        deferred?.reject(error);\n        onError?.(task, error);\n        checkIdle();\n      })\n      .finally(() => {\n        deferredMap.delete(task.id);\n        schedule();\n      });\n  }\n\n  function schedule() {\n    if (isPaused.value) return;\n\n    while (\n      runningCount.value < concurrency.value &&\n      pendingQueue.value.length > 0\n    ) {\n      const nextTask = pendingQueue.value.shift();\n      touchQueue();\n      if (!nextTask) break;\n\n      if (nextTask.status === \"pending\") pendingCount.value -= 1;\n\n      const deferred = deferredMap.get(nextTask.id);\n      executeTask(nextTask, deferred);\n    }\n  }\n\n  function add<T>(fn: TaskFunction<T>, meta?: M) {\n    const id = ++taskId;\n    const task: QueueTask<T, M> = {\n      id,\n      status: \"pending\",\n      createdAt: Date.now(),\n      run: fn,\n      meta,\n    };\n\n    tasks.value.push(task);\n    triggerRef(tasks);\n    pendingQueue.value.push(task);\n    triggerRef(pendingQueue);\n    pendingCount.value += 1;\n\n    const deferred = createDeferred<T>();\n    deferredMap.set(id, deferred as Deferred<unknown>);\n\n    schedule();\n\n    return { id, task, promise: deferred.promise };\n  }\n\n  function start(id: number): Promise<unknown> | undefined {\n    const task = tasks.value.find((t) => t.id === id);\n    if (!task || task.status !== \"pending\") return undefined;\n\n    const queueIndex = pendingQueue.value.findIndex((t) => t.id === id);\n    if (queueIndex !== -1) {\n      pendingQueue.value.splice(queueIndex, 1);\n      touchQueue();\n    }\n\n    const existingDeferred = deferredMap.get(id);\n    deferredMap.delete(id);\n\n    pendingCount.value -= 1;\n\n    const deferred = createDeferred<unknown>();\n\n    let runPromise: Promise<unknown>;\n    try {\n      runPromise = Promise.resolve(task.run());\n    } catch (error) {\n      runPromise = Promise.reject(error);\n    }\n\n    runningCount.value += 1;\n    task.status = \"running\";\n    task.startedAt = Date.now();\n    touchTasks();\n\n    runPromise\n      .then((result) => {\n        task.status = \"fulfilled\";\n        task.result = result;\n        task.finishedAt = Date.now();\n        completedCount.value += 1;\n        runningCount.value -= 1;\n        touchTasks();\n        trimHistory();\n        deferred.resolve(result);\n        existingDeferred?.resolve(result);\n        onSuccess?.(task);\n        checkIdle();\n      })\n      .catch((error) => {\n        task.status = \"rejected\";\n        task.error = error;\n        task.finishedAt = Date.now();\n        failedCount.value += 1;\n        runningCount.value -= 1;\n        touchTasks();\n        trimHistory();\n        deferred.reject(error);\n        existingDeferred?.reject(error);\n        onError?.(task, error);\n        checkIdle();\n      });\n\n    return deferred.promise;\n  }\n\n  function retry(id: number): RetryResult {\n    const task = tasks.value.find((t) => t.id === id);\n    if (!task) return { success: false, reason: \"not-found\" };\n\n    if (task.status !== \"rejected\")\n      return { success: false, reason: \"not-rejected\" };\n\n    if (pendingQueue.value.some((t) => t.id === id))\n      return { success: false, reason: \"already-queued\" };\n\n    failedCount.value -= 1;\n    pendingCount.value += 1;\n    task.status = \"pending\";\n    task.startedAt = undefined;\n    task.finishedAt = undefined;\n    task.result = undefined;\n    task.error = undefined;\n    touchTasks();\n\n    const deferred = createDeferred<unknown>();\n    deferredMap.set(id, deferred);\n    pendingQueue.value.push(task);\n    triggerRef(pendingQueue);\n    schedule();\n\n    return { success: true, promise: deferred.promise };\n  }\n\n  function remove(id: number): boolean {\n    const queueIndex = pendingQueue.value.findIndex((t) => t.id === id);\n    if (queueIndex === -1) return false;\n\n    pendingQueue.value.splice(queueIndex, 1);\n    touchQueue();\n\n    const taskIndex = tasks.value.findIndex((t) => t.id === id);\n    if (taskIndex !== -1) {\n      tasks.value.splice(taskIndex, 1);\n      touchTasks();\n    }\n\n    pendingCount.value -= 1;\n    deferredMap.get(id)?.reject(new Error(\"Task removed\"));\n    deferredMap.delete(id);\n\n    return true;\n  }\n\n  function clear() {\n    if (pendingQueue.value.length === 0) return;\n\n    const pendingIds = new Set(pendingQueue.value.map((t) => t.id));\n    const clearedCount = pendingIds.size;\n\n    pendingQueue.value = [];\n    triggerRef(pendingQueue);\n\n    tasks.value = tasks.value.filter((t) => !pendingIds.has(t.id));\n    triggerRef(tasks);\n\n    pendingCount.value -= clearedCount;\n\n    for (const id of pendingIds) {\n      deferredMap.get(id)?.reject(new Error(\"Queue cleared\"));\n      deferredMap.delete(id);\n    }\n  }\n\n  function pause() {\n    isPaused.value = true;\n  }\n\n  function resume() {\n    if (!isPaused.value) return;\n    isPaused.value = false;\n    schedule();\n  }\n\n  function setConcurrency(value: number) {\n    concurrency.value = clampConcurrency(value);\n    schedule();\n  }\n\n  function waitForIdle(): Promise<void> {\n    if (stats.value.isIdle) return Promise.resolve();\n\n    return new Promise((resolve) => {\n      const stop = watch(\n        () => stats.value.isIdle,\n        (idle) => {\n          if (idle) {\n            stop();\n            resolve();\n          }\n        },\n      );\n    });\n  }\n\n  // Watch for dynamic concurrency changes\n  if (\n    typeof initialConcurrency === \"function\" ||\n    typeof initialConcurrency === \"object\"\n  ) {\n    watch(\n      () => toValue(initialConcurrency),\n      (value) => {\n        concurrency.value = clampConcurrency(value);\n        schedule();\n      },\n    );\n  }\n\n  return {\n    tasks: shallowReadonly(tasks),\n    stats,\n    concurrency: shallowReadonly(concurrency),\n    add,\n    start,\n    retry,\n    remove,\n    clear,\n    pause,\n    resume,\n    setConcurrency,\n    waitForIdle,\n  };\n}\n\nexport type { MaybeRefOrGetter };\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "vue-reactive-queue",
+  "version": "0.0.0",
+  "description": "A Vue 3 composable for managing async task queues with reactive state, concurrency control, pause/resume, and retry support",
+  "homepage": "https://github.com/ruibaby/vue-reactive-queue",
+  "bugs": {
+    "url": "https://github.com/ruibaby/vue-reactive-queue/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ruibaby/vue-reactive-queue"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@types/node": "^22.19.7",
+    "@vitest/coverage-v8": "4.0.18",
+    "tsdown": "^0.20.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "vue": ">=3.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "check": "biome check . --write",
+    "prepublish": "pnpm run build"
+  }
+}