@muhgholy/next-drive 4.23.24 → 4.23.26

package/dist/client/index.cjs

@@ -4,6 +4,7 @@ var chunkHQTC3554_cjs = require('../chunk-HQTC3554.cjs');
 var chunkA65ZAA2Z_cjs = require('../chunk-A65ZAA2Z.cjs');
 var React3 = require('react');
 var jsxRuntime = require('react/jsx-runtime');
+var tus = require('tus-js-client');
 var reactSlot = require('@radix-ui/react-slot');
 var classVarianceAuthority = require('class-variance-authority');
 var ProgressPrimitive = require('@radix-ui/react-progress');
@@ -37,6 +38,7 @@ function _interopNamespace(e) {
 }
 
 var React3__namespace = /*#__PURE__*/_interopNamespace(React3);
+var tus__namespace = /*#__PURE__*/_interopNamespace(tus);
 var ProgressPrimitive__namespace = /*#__PURE__*/_interopNamespace(ProgressPrimitive);
 var SheetPrimitive__namespace = /*#__PURE__*/_interopNamespace(SheetPrimitive);
 var DropdownMenuPrimitive__namespace = /*#__PURE__*/_interopNamespace(DropdownMenuPrimitive);
@@ -332,8 +334,6 @@ var useDrive = () => {
   if (!context) throw new Error("useDrive must be used within a DriveProvider");
   return context;
 };
-
-// src/client/upload.ts
 var MAX_CONCURRENT_UPLOADS = 2;
 var getChunkSize = (fileSize) => {
   if (fileSize < 50 * 1024 * 1024) return 2 * 1024 * 1024;
@@ -367,161 +367,92 @@ var uploadFile = (options) => {
     onComplete
   } = options;
   const id = options.id ?? generateId();
-  const endpoint = apiEndpoint.replace(/\/$/, "");
-  const uploadUrl = `${endpoint}?action=upload`;
-  const controller = new AbortController();
-  let activeXhr = null;
-  let driveId;
-  let completedItem;
-  let cancelled = false;
-  const totalBytes = file.size;
+  const endpoint = `${apiEndpoint.replace(/\/$/, "")}?action=upload`;
   const chunkSize = getChunkSize(file.size);
-  const totalChunks = Math.ceil(file.size / chunkSize);
+  const totalChunks = Math.max(1, Math.ceil(file.size / chunkSize));
   const log = (type, message) => onLog?.({ id, type, message, timestamp: Date.now() });
-  const emitProgress = (currentChunk, uploadedBytes) => {
-    const percent = totalBytes === 0 ? 100 : Math.min(100, Math.round(uploadedBytes / totalBytes * 100));
-    onProgress?.({ id, percent, uploadedBytes, totalBytes, currentChunk, totalChunks });
+  let settle = () => {
   };
-  const sendChunk = (chunkIndex, formData, chunkStart) => new Promise((resolve) => {
-    const xhr = new XMLHttpRequest();
-    activeXhr = xhr;
-    log("info", `Sending chunk to ${uploadUrl}`);
-    xhr.upload.onprogress = (e) => {
-      if (e.lengthComputable) emitProgress(chunkIndex, chunkStart + e.loaded);
-    };
-    xhr.onload = () => {
-      activeXhr = null;
-      const status = xhr.status;
-      const text = xhr.responseText;
-      if (status < 200 || status >= 300) {
-        log("error", `HTTP ${status}: ${xhr.statusText}`);
-        try {
-          const json = JSON.parse(text);
-          const msg = json.message || json.error?.message || `Status ${status}`;
-          log("error", `Server response: ${msg}`);
-          const canRetry = [408, 429, 502, 503, 504].includes(status);
-          if (canRetry) log("warning", `Error is retryable (status ${status})`);
-          resolve([false, msg, canRetry]);
-        } catch {
-          log("error", `Failed to parse error response: ${text.slice(0, 100)}`);
-          const isRetryable = status >= 500 || status === 429;
-          resolve([false, `Server error ${status}: ${text.slice(0, 100)}`, isRetryable]);
-        }
-        return;
+  const promise = new Promise((resolve) => {
+    settle = resolve;
+  });
+  let completedItem;
+  let cancelled = false;
+  const metadata = {
+    filename: file.name,
+    filetype: file.type || "application/octet-stream",
+    folderId: folderId || "root"
+  };
+  if (conflictAction) metadata.conflictAction = conflictAction;
+  const upload = new tus__namespace.Upload(file, {
+    endpoint,
+    chunkSize,
+    // ** Retry with backoff. On a dropped connection tus first re-checks the server offset (HEAD)
+    // ** and resumes from there — this is what prevents the "session expired" failures at ~100%.
+    retryDelays: [0, 1e3, 3e3, 5e3, 1e4],
+    removeFingerprintOnSuccess: true,
+    metadata,
+    headers: accountId ? { "x-drive-account": accountId } : {},
+    onBeforeRequest(req) {
+      if (withCredentials) {
+        const xhr = req.getUnderlyingObject();
+        if (xhr && "withCredentials" in xhr) xhr.withCredentials = true;
       }
-      try {
-        const data = JSON.parse(text);
-        if (data.status !== 200) {
-          log("error", `Upload API error: ${data.message || "Unknown error"}`);
-          resolve([false, data.message || "Upload failed", false]);
-          return;
-        }
-        log("success", `Chunk uploaded successfully`);
-        resolve([true, data.data, false]);
-      } catch {
-        log("error", `Failed to parse response: ${text.slice(0, 100)}`);
-        resolve([false, "Invalid server response", true]);
+    },
+    onShouldRetry(err) {
+      const status = err?.originalResponse?.getStatus?.() ?? 0;
+      if ([400, 401, 403, 413].includes(status)) {
+        log("error", `Non-retryable error (status ${status})`);
+        return false;
       }
-    };
-    xhr.onerror = () => {
-      activeXhr = null;
-      log("error", `Network/Fetch error: request failed`);
-      resolve([false, `Upload connection failed`, true]);
-    };
-    xhr.onabort = () => {
-      activeXhr = null;
-      resolve([false, "Cancelled", false]);
-    };
-    xhr.open("POST", uploadUrl);
-    if (accountId) xhr.setRequestHeader("x-drive-account", accountId);
-    xhr.withCredentials = withCredentials;
-    xhr.send(formData);
-  });
-  const run = async () => {
-    log("info", `Starting upload: ${file.name} (${file.size} bytes)`);
-    log("info", `File split into ${totalChunks} chunks of ${chunkSize} bytes each`);
-    emitProgress(0, 0);
-    try {
-      for (let i = 0; i < totalChunks; i++) {
-        if (controller.signal.aborted) throw new Error("Cancelled");
-        log("info", `Processing chunk ${i + 1}/${totalChunks}`);
-        const start = i * chunkSize;
-        const end = Math.min(start + chunkSize, file.size);
-        const chunk = file.slice(start, end);
-        const formData = new FormData();
-        formData.append("chunk", chunk);
-        formData.append("chunkIndex", String(i));
-        formData.append("totalChunks", String(totalChunks));
-        formData.append("fileName", file.name);
-        formData.append("fileSize", String(file.size));
-        formData.append("fileType", file.type);
-        formData.append("folderId", folderId || "root");
-        if (conflictAction) formData.append("conflictAction", conflictAction);
-        if (driveId) formData.append("driveId", driveId);
-        let attempts = 0;
-        let success = false;
-        while (!success && attempts < 3 && !controller.signal.aborted) {
-          const [ok, result, canRetry] = await sendChunk(i, formData, start);
-          if (ok) {
-            success = true;
-            emitProgress(i + 1, end);
-            if (result.type === "UPLOAD_STARTED" && result.driveId) {
-              driveId = result.driveId;
-              log("success", `Upload session started with ID: ${driveId}`);
-            } else if (result.type === "UPLOAD_COMPLETE") {
-              if (result.driveId) driveId = result.driveId;
-              log("success", `Upload completed successfully`);
-              completedItem = result.item;
-            }
-          } else {
-            if (result === "Cancelled") throw new Error("Cancelled");
-            if (!canRetry) {
-              log("error", `Non-retryable error: ${result}`);
-              throw new Error(result);
-            }
-            attempts++;
-            log("warning", `Retry attempt ${attempts}/3 after error`);
-            if (attempts === 3) {
-              log("error", `Max retry attempts reached: ${result}`);
-              throw new Error(result);
-            }
-            await new Promise((r) => setTimeout(r, 1e3 * attempts));
-          }
+      log("warning", `Upload interrupted (status ${status}), retrying`);
+      return true;
+    },
+    onProgress(bytesUploaded, bytesTotal) {
+      const percent = bytesTotal === 0 ? 100 : Math.min(100, Math.round(bytesUploaded / bytesTotal * 100));
+      onProgress?.({
+        id,
+        percent,
+        uploadedBytes: bytesUploaded,
+        totalBytes: bytesTotal,
+        currentChunk: Math.min(totalChunks, Math.floor(bytesUploaded / chunkSize)),
+        totalChunks
+      });
+    },
+    onAfterResponse(_req, res) {
+      const header = res.getHeader("X-Drive-Item");
+      if (header) {
+        try {
+          completedItem = JSON.parse(decodeURIComponent(header));
+        } catch {
         }
-        if (!success && controller.signal.aborted) throw new Error("Cancelled");
       }
-      log("success", `All ${totalChunks} chunks uploaded successfully`);
-      emitProgress(totalChunks, totalBytes);
+    },
+    onSuccess() {
+      log("success", "Upload completed successfully");
       if (completedItem !== void 0) onComplete?.(completedItem);
-      return { id, status: "complete", driveId: driveId ?? "", file: toDriveFile(completedItem), item: completedItem };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (errorMessage === "Cancelled") {
-        log("warning", "Upload cancelled by user");
-        return { id, status: "cancelled", driveId: driveId ?? null };
-      }
-      log("error", `Upload failed: ${errorMessage}`);
-      return { id, status: "error", driveId: driveId ?? null, error: errorMessage };
+      settle({ id, status: "complete", driveId: completedItem?.id ?? "", file: toDriveFile(completedItem), item: completedItem });
+    },
+    onError(error) {
+      const message = error instanceof Error ? error.message : "Upload failed";
+      log("error", `Upload failed: ${message}`);
+      settle({ id, status: "error", driveId: null, error: message });
     }
-  };
+  });
   const cancel = () => {
     if (cancelled) return;
     cancelled = true;
-    controller.abort();
-    activeXhr?.abort();
-    if (driveId) {
-      fetch(`${endpoint}?action=cancel&id=${driveId}`, {
-        method: "POST",
-        credentials: withCredentials ? "include" : "same-origin"
-      }).catch(() => {
-      });
-    }
+    upload.abort(true).catch(() => {
+    });
+    settle({ id, status: "cancelled", driveId: null });
   };
   if (signal) {
     if (signal.aborted) cancel();
     else signal.addEventListener("abort", cancel, { once: true });
   }
-  return { id, promise: run(), cancel };
+  log("info", `Starting upload: ${file.name} (${file.size} bytes)`);
+  upload.start();
+  return { id, promise, cancel };
 };
 var uploadFiles = (files, options) => {
   const { concurrency = MAX_CONCURRENT_UPLOADS, onFileComplete, ...base } = options;