@weirdfingers/boards 0.6.2 → 0.7.0

package/dist/index.mjs

@@ -815,6 +815,11 @@ var RETRY_GENERATION = gql`
     }
   }
 `;
+var DELETE_GENERATION = gql`
+  mutation DeleteGeneration($id: UUID!) {
+    deleteGeneration(id: $id)
+  }
+`;
 var UPLOAD_ARTIFACT_FROM_URL = gql`
   ${GENERATION_FRAGMENT}
   mutation UploadArtifactFromUrl($input: UploadArtifactInput!) {
@@ -1103,6 +1108,7 @@ function useGeneration() {
   const [, createGenerationMutation] = useMutation3(CREATE_GENERATION);
   const [, cancelGenerationMutation] = useMutation3(CANCEL_GENERATION);
   const [, retryGenerationMutation] = useMutation3(RETRY_GENERATION);
+  const [, deleteGenerationMutation] = useMutation3(DELETE_GENERATION);
   useEffect2(() => {
     return () => {
       abortControllers.current.forEach((controller) => {
@@ -1312,6 +1318,36 @@ function useGeneration() {
     },
     [retryGenerationMutation, connectToSSE]
   );
+  const deleteGeneration = useCallback5(
+    async (jobId) => {
+      try {
+        const result2 = await deleteGenerationMutation({ id: jobId });
+        if (result2.error) {
+          throw new Error(result2.error.message);
+        }
+        if (!result2.data?.deleteGeneration) {
+          throw new Error("Failed to delete generation");
+        }
+        const controller = abortControllers.current.get(jobId);
+        if (controller) {
+          controller.abort();
+          abortControllers.current.delete(jobId);
+        }
+        if (progress?.jobId === jobId) {
+          setProgress(null);
+          setResult(null);
+          setIsGenerating(false);
+        }
+        setHistory((prev) => prev.filter((item) => item.jobId !== jobId));
+      } catch (err) {
+        setError(
+          err instanceof Error ? err : new Error("Failed to delete generation")
+        );
+        throw err;
+      }
+    },
+    [deleteGenerationMutation, progress]
+  );
   const clearHistory = useCallback5(() => {
     setHistory([]);
   }, []);
@@ -1323,6 +1359,7 @@ function useGeneration() {
     submit,
     cancel,
     retry,
+    deleteGeneration,
     history,
     clearHistory
   };
@@ -1345,21 +1382,44 @@ function useGenerators(options = {}) {
   };
 }
 
-// src/hooks/useUpload.ts
-import { useCallback as useCallback6, useState as useState5 } from "react";
+// src/hooks/useMultiUpload.ts
+import { useCallback as useCallback6, useState as useState5, useRef as useRef2 } from "react";
 import { useMutation as useMutation4 } from "urql";
-function useUpload() {
-  const [isUploading, setIsUploading] = useState5(false);
-  const [progress, setProgress] = useState5(0);
-  const [error, setError] = useState5(null);
+var uploadIdCounter = 0;
+function generateUploadId() {
+  return `upload-${Date.now()}-${++uploadIdCounter}`;
+}
+function getFileName(source) {
+  if (typeof source === "string") {
+    try {
+      const url = new URL(source);
+      const pathParts = url.pathname.split("/");
+      return pathParts[pathParts.length - 1] || source;
+    } catch {
+      return source;
+    }
+  }
+  return source.name;
+}
+function useMultiUpload() {
+  const [uploads, setUploads] = useState5([]);
+  const abortControllersRef = useRef2(/* @__PURE__ */ new Map());
   const { apiUrl } = useApiConfig();
   const auth = useAuth();
   const [, uploadFromUrlMutation] = useMutation4(UPLOAD_ARTIFACT_FROM_URL);
-  const upload = useCallback6(
-    async (request) => {
-      setError(null);
-      setProgress(0);
-      setIsUploading(true);
+  const updateUpload = useCallback6(
+    (uploadId, updates) => {
+      setUploads(
+        (prev) => prev.map(
+          (item) => item.id === uploadId ? { ...item, ...updates } : item
+        )
+      );
+    },
+    []
+  );
+  const uploadSingle = useCallback6(
+    async (uploadId, request) => {
+      updateUpload(uploadId, { status: "uploading", progress: 0 });
       try {
         if (typeof request.source === "string") {
           const result2 = await uploadFromUrlMutation({
@@ -1377,9 +1437,7 @@ function useUpload() {
           if (!result2.data?.uploadArtifact) {
             throw new Error("Upload failed");
           }
-          setProgress(100);
-          setIsUploading(false);
-          return {
+          const uploadResult = {
             id: result2.data.uploadArtifact.id,
             storageUrl: result2.data.uploadArtifact.storageUrl,
             thumbnailUrl: result2.data.uploadArtifact.thumbnailUrl,
@@ -1387,6 +1445,12 @@ function useUpload() {
             artifactType: result2.data.uploadArtifact.artifactType,
             generatorName: result2.data.uploadArtifact.generatorName
           };
+          updateUpload(uploadId, {
+            status: "completed",
+            progress: 100,
+            result: uploadResult
+          });
+          return uploadResult;
         }
         const formData = new FormData();
         formData.append("board_id", request.boardId);
@@ -1403,68 +1467,128 @@ function useUpload() {
         if (token) {
           headers.Authorization = `Bearer ${token}`;
         }
-        const result = await new Promise((resolve, reject) => {
-          const xhr = new XMLHttpRequest();
-          xhr.upload.addEventListener("progress", (e) => {
-            if (e.lengthComputable) {
-              const percentComplete = e.loaded / e.total * 100;
-              setProgress(percentComplete);
-            }
-          });
-          xhr.addEventListener("load", () => {
-            if (xhr.status === 200) {
-              try {
-                const data = JSON.parse(xhr.responseText);
-                resolve({
-                  id: data.id,
-                  storageUrl: data.storageUrl,
-                  thumbnailUrl: data.thumbnailUrl,
-                  status: "completed",
-                  artifactType: data.artifactType,
-                  generatorName: data.generatorName
-                });
-              } catch (err) {
-                reject(new Error("Failed to parse response"));
+        const result = await new Promise(
+          (resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            abortControllersRef.current.set(uploadId, () => xhr.abort());
+            const cleanup = () => {
+              abortControllersRef.current.delete(uploadId);
+            };
+            xhr.upload.addEventListener("progress", (e) => {
+              if (e.lengthComputable) {
+                const percentComplete = e.loaded / e.total * 100;
+                updateUpload(uploadId, { progress: percentComplete });
               }
-            } else {
-              try {
-                const errorData = JSON.parse(xhr.responseText);
-                reject(new Error(errorData.detail || `Upload failed: ${xhr.statusText}`));
-              } catch {
-                reject(new Error(`Upload failed: ${xhr.statusText}`));
+            });
+            xhr.addEventListener("load", () => {
+              cleanup();
+              if (xhr.status === 200) {
+                try {
+                  const data = JSON.parse(xhr.responseText);
+                  resolve({
+                    id: data.id,
+                    storageUrl: data.storageUrl,
+                    thumbnailUrl: data.thumbnailUrl,
+                    status: "completed",
+                    artifactType: data.artifactType,
+                    generatorName: data.generatorName
+                  });
+                } catch (err) {
+                  reject(new Error("Failed to parse response"));
+                }
+              } else {
+                try {
+                  const errorData = JSON.parse(xhr.responseText);
+                  reject(
+                    new Error(
+                      errorData.detail || `Upload failed: ${xhr.statusText}`
+                    )
+                  );
+                } catch {
+                  reject(new Error(`Upload failed: ${xhr.statusText}`));
+                }
               }
-            }
-          });
-          xhr.addEventListener("error", () => {
-            reject(new Error("Upload failed: Network error"));
-          });
-          xhr.addEventListener("abort", () => {
-            reject(new Error("Upload cancelled"));
-          });
-          xhr.open("POST", `${apiUrl}/api/uploads/artifact`);
-          Object.entries(headers).forEach(([key, value]) => {
-            xhr.setRequestHeader(key, value);
-          });
-          xhr.send(formData);
+            });
+            xhr.addEventListener("error", () => {
+              cleanup();
+              reject(new Error("Upload failed: Network error"));
+            });
+            xhr.addEventListener("abort", () => {
+              cleanup();
+              reject(new Error("Upload cancelled"));
+            });
+            xhr.addEventListener("loadend", () => {
+              cleanup();
+            });
+            xhr.open("POST", `${apiUrl}/api/uploads/artifact`);
+            Object.entries(headers).forEach(([key, value]) => {
+              xhr.setRequestHeader(key, value);
+            });
+            xhr.send(formData);
+          }
+        );
+        updateUpload(uploadId, {
+          status: "completed",
+          progress: 100,
+          result
         });
-        setProgress(100);
-        setIsUploading(false);
         return result;
       } catch (err) {
         const uploadError = err instanceof Error ? err : new Error("Upload failed");
-        setError(uploadError);
-        setIsUploading(false);
-        setProgress(0);
+        updateUpload(uploadId, {
+          status: "failed",
+          error: uploadError
+        });
         throw uploadError;
       }
     },
-    [uploadFromUrlMutation, apiUrl, auth]
+    [uploadFromUrlMutation, apiUrl, auth, updateUpload]
   );
+  const uploadMultiple = useCallback6(
+    async (requests) => {
+      const newUploads = requests.map((request) => ({
+        id: generateUploadId(),
+        file: request.source,
+        fileName: getFileName(request.source),
+        status: "pending",
+        progress: 0
+      }));
+      setUploads((prev) => [...prev, ...newUploads]);
+      const results = await Promise.allSettled(
+        requests.map(
+          (request, index) => uploadSingle(newUploads[index].id, request)
+        )
+      );
+      const successfulResults = [];
+      results.forEach((result) => {
+        if (result.status === "fulfilled") {
+          successfulResults.push(result.value);
+        }
+      });
+      return successfulResults;
+    },
+    [uploadSingle]
+  );
+  const clearUploads = useCallback6(() => {
+    abortControllersRef.current.forEach((abort) => abort());
+    abortControllersRef.current.clear();
+    setUploads([]);
+  }, []);
+  const cancelUpload = useCallback6((uploadId) => {
+    const abort = abortControllersRef.current.get(uploadId);
+    if (abort) {
+      abort();
+    }
+  }, []);
+  const isUploading = uploads.some((u) => u.status === "uploading");
+  const overallProgress = uploads.length > 0 ? uploads.reduce((sum, u) => sum + u.progress, 0) / uploads.length : 0;
   return {
-    upload,
+    uploadMultiple,
+    uploads,
     isUploading,
-    progress,
-    error
+    overallProgress,
+    clearUploads,
+    cancelUpload
   };
 }
 
@@ -1581,6 +1705,7 @@ export {
   CREATE_BOARD,
   CREATE_GENERATION,
   DELETE_BOARD,
+  DELETE_GENERATION,
   DESCENDANT_NODE_FRAGMENT,
   GENERATION_FRAGMENT,
   GET_ANCESTRY,
@@ -1620,6 +1745,6 @@ export {
   useGenerators,
   useInputArtifacts,
   useLineage,
-  useUpload
+  useMultiUpload
 };
 //# sourceMappingURL=index.mjs.map