web: core system for queue & queen bee, move remux to new system

it's 3 am and i think i had a divine intervention

web/src/lib/state/queen-bee/current-tasks.ts

@@ -0,0 +1,40 @@
+import { readable, type Updater } from "svelte/store";
+
+import type { CobaltWorkerProgress } from "$lib/types/workers";
+import type { CobaltCurrentTasks, CobaltCurrentTaskItem } from "$lib/types/queen-bee";
+
+let update: (_: Updater<CobaltCurrentTasks>) => void;
+
+const currentTasks = readable<CobaltCurrentTasks>(
+    {},
+    (_, _update) => { update = _update }
+);
+
+export function addWorkerToQueue(item: CobaltCurrentTaskItem) {
+    update(tasks => {
+        tasks[item.id] = item;
+        return tasks;
+    });
+}
+
+export function removeWorkerFromQueue(id: string) {
+    update(tasks => {
+        delete tasks[id];
+        return tasks;
+    });
+}
+
+export function updateWorkerProgress(id: string, progress: CobaltWorkerProgress) {
+    update(tasks => {
+        tasks[id].progress = progress;
+        return tasks;
+    });
+}
+
+export function clearQueue() {
+    update(() => {
+        return {};
+    });
+}
+
+export { currentTasks };

web/src/lib/state/queen-bee/queue.ts

@@ -0,0 +1,84 @@
+import { readable, type Updater } from "svelte/store";
+import type { CobaltQueue, CobaltQueueItem } from "$lib/types/queue";
+import { checkTasks } from "$lib/queen-bee/scheduler";
+import { removeWorkerFromQueue } from "./current-tasks";
+
+let update: (_: Updater<CobaltQueue>) => void;
+
+const queue = readable<CobaltQueue>(
+    {},
+    (_, _update) => { update = _update }
+);
+
+export function addItem(item: CobaltQueueItem) {
+    update(queueData => {
+        queueData[item.id] = item;
+        return queueData;
+    });
+
+    checkTasks();
+}
+
+export function itemError(id: string, workerId: string, error: string) {
+    update(queueData => {
+        if (queueData[id]) {
+            queueData[id] = {
+                ...queueData[id],
+                state: "error",
+                errorCode: error,
+            }
+        }
+        return queueData;
+    });
+
+    removeWorkerFromQueue(workerId);
+    checkTasks();
+}
+
+export function itemDone(id: string, workerId: string, file: File) {
+    update(queueData => {
+        if (queueData[id]) {
+            queueData[id] = {
+                ...queueData[id],
+                state: "done",
+                resultFile: file,
+            }
+        }
+        return queueData;
+    });
+
+    removeWorkerFromQueue(workerId);
+    checkTasks();
+}
+
+export function itemRunning(id: string, step: number) {
+    update(queueData => {
+        if (queueData[id]) {
+            queueData[id] = {
+                ...queueData[id],
+                state: "running",
+                currentStep: step,
+            }
+        }
+        return queueData;
+    });
+
+    checkTasks();
+}
+
+export function removeItem(id: string) {
+    update(queueData => {
+        delete queueData[id];
+        return queueData;
+    });
+
+    checkTasks();
+}
+
+export function clearQueue() {
+    update(() => {
+        return {};
+    });
+}
+
+export { queue };

web/src/lib/state/queue.ts

@@ -1,70 +0,0 @@
-import { merge } from "ts-deepmerge";
-import { get, readable, type Updater } from "svelte/store";
-import type { OngoingQueueItem, QueueItem } from "$lib/types/queue";
-
-type Queue = {
-    [id: string]: QueueItem;
-}
-
-type OngoingQueue = {
-    [id: string]: OngoingQueueItem;
-}
-
-let update: (_: Updater<Queue>) => void;
-
-const queue = readable<Queue>(
-    {},
-    (_, _update) => { update = _update }
-);
-
-export function addToQueue(item: QueueItem) {
-    update(queueData => {
-        queueData[item.id] = item;
-        return queueData;
-    });
-}
-
-export function removeFromQueue(id: string) {
-    update(queueData => {
-        delete queueData[id];
-        return queueData;
-    });
-}
-
-let updateOngoing: (_: Updater<OngoingQueue>) => void;
-
-const ongoingQueue = readable<OngoingQueue>(
-    {},
-    (_, _update) => { updateOngoing = _update }
-);
-
-export function updateOngoingQueue(id: string, itemInfo: Partial<OngoingQueueItem> = {}) {
-    updateOngoing(queueData => {
-        if (get(queue)?.id) {
-            queueData[id] = merge(queueData[id], {
-                id,
-                ...itemInfo,
-            });
-        }
-
-        return queueData;
-    });
-}
-
-export function removeFromOngoingQueue(id: string) {
-    updateOngoing(queue => {
-        delete queue[id];
-        return queue;
-    });
-}
-
-export function nukeEntireQueue() {
-    update(() => {
-        return {};
-    });
-    updateOngoing(() => {
-        return {};
-    });
-}
-
-export { queue, ongoingQueue };