@arbidocs/sdk 0.3.47 → 0.3.49

package/dist/index.cjs

@@ -4451,7 +4451,8 @@ var DOC_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "completed",
   "failed",
   "skipped",
-  "empty"
+  "empty",
+  "low-content"
 ]);
 function createDocumentWaiter(options) {
   const { baseUrl, accessToken, onStatus } = options;
@@ -4655,6 +4656,7 @@ __export(documents_exports, {
   listAll: () => listAll,
   listDocuments: () => listDocuments,
   listPaginated: () => listPaginated,
+  mimeFromName: () => mimeFromName,
   sanitizeFolderPath: () => sanitizeFolderPath,
   updateDocuments: () => updateDocuments,
   uploadDocumentsDirect: () => uploadDocumentsDirect,
@@ -4804,11 +4806,11 @@ async function updateDocuments(arbi, documents) {
     "Failed to update documents"
   );
 }
-async function uploadUrl(arbi, urls, workspaceId, shared = false) {
+async function uploadUrl(arbi, urls, shared = false) {
   return requireData(
     await arbi.fetch.POST("/v1/document/upload-url", {
       params: {
-        query: { urls, workspace_ext_id: workspaceId, shared }
+        query: { urls, shared }
       }
     }),
     "Failed to upload from URLs"
@@ -4821,29 +4823,31 @@ async function getParsedContent(auth, docId, stage) {
   });
   return res.json();
 }
-async function uploadFile(auth, workspaceId, fileData, fileName, options) {
+async function uploadFile(auth, fileData, fileName, options) {
   const formData = new FormData();
   formData.append("files", fileData, fileName);
-  const params = new URLSearchParams({ workspace_ext_id: workspaceId });
+  const params = new URLSearchParams();
   if (options?.folder) params.set("folder", sanitizeFolderPath(options.folder));
   if (options?.configExtId) params.set("config_ext_id", options.configExtId);
+  const qs = params.toString();
   const res = await authenticatedFetch({
     ...auth,
-    path: `/v1/document/upload?${params.toString()}`,
+    path: qs ? `/v1/document/upload?${qs}` : `/v1/document/upload`,
     method: "POST",
     body: formData
   });
   return res.json();
 }
-async function uploadFiles(auth, workspaceId, files, options) {
+async function uploadFiles(auth, files, options) {
   const formData = new FormData();
   for (const f2 of files) formData.append("files", f2.data, f2.name);
-  const params = new URLSearchParams({ workspace_ext_id: workspaceId });
+  const params = new URLSearchParams();
   if (options?.folder) params.set("folder", sanitizeFolderPath(options.folder));
   if (options?.configExtId) params.set("config_ext_id", options.configExtId);
+  const qs = params.toString();
   const res = await authenticatedFetch({
     ...auth,
-    path: `/v1/document/upload?${params.toString()}`,
+    path: qs ? `/v1/document/upload?${qs}` : `/v1/document/upload`,
     method: "POST",
     body: formData
   });
@@ -4855,6 +4859,68 @@ async function downloadDocument(auth, docId) {
     path: `/v1/document/${docId}/download`
   });
 }
+function mimeFromName(name) {
+  const dot = name.lastIndexOf(".");
+  const ext = dot === -1 ? "" : name.slice(dot).toLowerCase();
+  switch (ext) {
+    case ".pdf":
+      return "application/pdf";
+    case ".txt":
+      return "text/plain";
+    case ".md":
+      return "text/markdown";
+    case ".html":
+    case ".htm":
+      return "text/html";
+    case ".doc":
+      return "application/msword";
+    case ".docx":
+      return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    case ".xls":
+      return "application/vnd.ms-excel";
+    case ".xlsx":
+      return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    case ".ppt":
+      return "application/vnd.ms-powerpoint";
+    case ".pptx":
+      return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    case ".eml":
+      return "message/rfc822";
+    default:
+      return void 0;
+  }
+}
+async function presignedPut(url, body, onProgress) {
+  const XhrGlobal = globalThis.XMLHttpRequest;
+  if (XhrGlobal) {
+    await new Promise((resolve2, reject) => {
+      const xhr = new XhrGlobal();
+      xhr.open("PUT", url);
+      if (onProgress) {
+        xhr.upload.addEventListener("progress", (e) => {
+          if (e.lengthComputable) onProgress(e.loaded, e.total);
+        });
+      }
+      xhr.addEventListener("load", () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          resolve2();
+        } else {
+          const snippet = (xhr.responseText || "").slice(0, 200);
+          reject(new Error(`Presigned PUT failed: ${xhr.status} ${snippet}`));
+        }
+      });
+      xhr.addEventListener("error", () => reject(new Error("Presigned PUT network error")));
+      xhr.addEventListener("abort", () => reject(new Error("Presigned PUT aborted")));
+      xhr.send(body);
+    });
+    return;
+  }
+  const putRes = await fetch(url, { method: "PUT", body });
+  if (!putRes.ok) {
+    const snippet = await putRes.text().catch(() => "");
+    throw new Error(`Presigned PUT failed: ${putRes.status} ${snippet.slice(0, 200)}`);
+  }
+}
 async function uploadDocumentsDirect(arbi, workspaceKey, files, options) {
   if (files.length === 0) return { doc_ext_ids: [], skipped: [] };
   const SECRETBOX_ENVELOPE_OVERHEAD = 40;
@@ -4887,6 +4953,11 @@ async function uploadDocumentsDirect(arbi, workspaceKey, files, options) {
   }
   const skipped = [];
   const toCommit = [];
+  const indexByName = /* @__PURE__ */ new Map();
+  files.forEach((f2, i2) => {
+    if (!indexByName.has(f2.name)) indexByName.set(f2.name, []);
+    indexByName.get(f2.name).push(i2);
+  });
   for (const item of items) {
     if (item.status !== "uploading" || !item.upload_url || !item.doc_ext_id) {
       skipped.push({
@@ -4896,21 +4967,34 @@ async function uploadDocumentsDirect(arbi, workspaceKey, files, options) {
       continue;
     }
     const queue = bytesByName.get(item.file_name);
-    if (!queue || queue.length === 0) {
+    const idxQueue = indexByName.get(item.file_name);
+    if (!queue || queue.length === 0 || !idxQueue || idxQueue.length === 0) {
       throw new Error(`upload-init returned slot for unknown file: ${item.file_name}`);
     }
     const raw = queue.shift();
+    const fileIndex = idxQueue.shift();
     const ciphertext = client.encryptFile(raw, workspaceKey);
-    const putRes = await fetch(item.upload_url, {
-      method: "PUT",
-      body: ciphertext
-    });
-    if (!putRes.ok) {
-      const body = await putRes.text().catch(() => "");
+    const total = ciphertext.length;
+    try {
+      await presignedPut(item.upload_url, ciphertext, (loaded, putTotal) => {
+        options?.onBytesProgress?.({
+          fileIndex,
+          fileName: item.file_name,
+          loaded,
+          total: putTotal
+        });
+      });
+    } catch (err) {
       throw new Error(
-        `Presigned PUT for ${item.doc_ext_id} failed: ${putRes.status} ${body.slice(0, 200)}`
+        `Presigned PUT for ${item.doc_ext_id} failed: ${err instanceof Error ? err.message : String(err)}`
       );
     }
+    options?.onBytesProgress?.({
+      fileIndex,
+      fileName: item.file_name,
+      loaded: total,
+      total
+    });
     toCommit.push(item.doc_ext_id);
   }
   if (toCommit.length === 0) {
@@ -5766,19 +5850,19 @@ var Arbi = class {
     get: (externalIds) => getDocuments(this.requireClient(), externalIds),
     delete: (externalIds) => deleteDocuments(this.requireClient(), externalIds),
     update: (documents) => updateDocuments(this.requireClient(), documents),
-    uploadUrl: (urls, shared, workspaceId) => uploadUrl(
-      this.requireClient(),
-      urls,
-      workspaceId ?? this.requireWorkspace(),
-      shared
-    ),
-    uploadFile: (fileData, fileName, options) => uploadFile(
-      this.getAuthHeaders(),
-      options?.workspaceId ?? this.requireWorkspace(),
-      fileData,
-      fileName,
-      options?.folder ? { folder: options.folder } : void 0
-    ),
+    uploadUrl: (urls, shared) => {
+      this.requireWorkspace();
+      return uploadUrl(this.requireClient(), urls, shared);
+    },
+    uploadFile: (fileData, fileName, options) => {
+      this.requireWorkspace();
+      return uploadFile(
+        this.getAuthHeaders(),
+        fileData,
+        fileName,
+        options?.folder ? { folder: options.folder } : void 0
+      );
+    },
     download: (docId) => downloadDocument(this.getAuthHeaders(), docId),
     getParsedContent: (docId, stage) => getParsedContent(this.getAuthHeaders(), docId, stage)
   };
@@ -5976,7 +6060,8 @@ function chunk(arr, size) {
   }
   return chunks;
 }
-function readFileAsBlob(filePath, fileSize) {
+function readFileAsBlob(filePath, fileSize, fileName) {
+  const type = fileName ? mimeFromName(fileName) ?? "" : "";
   if (fileSize > NODE_BUFFER_LIMIT) {
     const chunks = [];
     const CHUNK = 256 * 1024 * 1024;
@@ -5990,15 +6075,15 @@ function readFileAsBlob(filePath, fileSize) {
       pos += len;
     }
     fs2__default.default.closeSync(fd);
-    return new Blob(chunks);
+    return new Blob(chunks, { type });
   }
-  return new Blob([fs2__default.default.readFileSync(filePath)]);
+  return new Blob([fs2__default.default.readFileSync(filePath)], { type });
 }
-async function uploadLocalFile(auth, workspaceId, filePath, options) {
+async function uploadLocalFile(auth, filePath, options) {
   const stat = fs2__default.default.statSync(filePath);
   const fileName = path2__default.default.basename(filePath);
-  const blob = readFileAsBlob(filePath, stat.size);
-  const result = await uploadFile(auth, workspaceId, blob, fileName, options);
+  const blob = readFileAsBlob(filePath, stat.size, fileName);
+  const result = await uploadFile(auth, blob, fileName, options);
   return { ...result, fileName };
 }
 async function uploadLocalFilesDirect(arbi, workspaceKey, filePaths, options) {
@@ -6157,37 +6242,7 @@ async function uploadLocalArchiveDirect(arbi, workspaceKey, archivePath, options
     }
   }
 }
-function mimeFromName(name) {
-  const ext = path2__default.default.extname(name).toLowerCase();
-  switch (ext) {
-    case ".pdf":
-      return "application/pdf";
-    case ".txt":
-      return "text/plain";
-    case ".md":
-      return "text/markdown";
-    case ".html":
-    case ".htm":
-      return "text/html";
-    case ".doc":
-      return "application/msword";
-    case ".docx":
-      return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
-    case ".xls":
-      return "application/vnd.ms-excel";
-    case ".xlsx":
-      return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
-    case ".ppt":
-      return "application/vnd.ms-powerpoint";
-    case ".pptx":
-      return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
-    case ".eml":
-      return "message/rfc822";
-    default:
-      return void 0;
-  }
-}
-async function uploadDirectory(auth, workspaceId, dirPath, options) {
+async function uploadDirectory(auth, dirPath, options) {
   const resolvedDir = path2__default.default.resolve(dirPath);
   const dirName = path2__default.default.basename(resolvedDir);
   const entries = collectFiles(resolvedDir);
@@ -6243,7 +6298,7 @@ async function uploadDirectory(auth, workspaceId, dirPath, options) {
           });
         } else {
           try {
-            uploadable.push({ data: readFileAsBlob(f2.absolutePath, f2.size), name: f2.name });
+            uploadable.push({ data: readFileAsBlob(f2.absolutePath, f2.size, f2.name), name: f2.name });
           } catch (err) {
             batchSkipped.push({
               file_name: f2.name,
@@ -6254,7 +6309,7 @@ async function uploadDirectory(auth, workspaceId, dirPath, options) {
       }
       let result = { doc_ext_ids: [], skipped: [] };
       if (uploadable.length > 0) {
-        result = await uploadFiles(auth, workspaceId, uploadable, {
+        result = await uploadFiles(auth, uploadable, {
           folder,
           configExtId: options?.configExtId
         });
@@ -6279,7 +6334,7 @@ async function uploadDirectory(auth, workspaceId, dirPath, options) {
   }
   return { doc_ext_ids: allDocIds, skipped: allSkipped, folders };
 }
-async function uploadZip(auth, workspaceId, zipPath, options) {
+async function uploadZip(auth, zipPath, options) {
   const JSZip = (await import('jszip')).default;
   const zipBuffer = fs2__default.default.readFileSync(zipPath);
   const zip = await JSZip.loadAsync(zipBuffer);
@@ -6343,7 +6398,7 @@ async function uploadZip(auth, workspaceId, zipPath, options) {
         data: new Blob([f2.data]),
         name: f2.name
       }));
-      const result = await uploadFiles(auth, workspaceId, blobs, {
+      const result = await uploadFiles(auth, blobs, {
         folder,
         configExtId: options?.configExtId
       });
@@ -6414,7 +6469,7 @@ function isTransientError(err) {
 function sleep2(ms) {
   return new Promise((r2) => setTimeout(r2, ms));
 }
-async function uploadManifest(auth, workspaceId, paths, options) {
+async function uploadManifest(auth, paths, options) {
   const maxRetries = Math.max(1, options?.maxRetries ?? 3);
   const outcomes = [];
   const summary = {
@@ -6535,7 +6590,7 @@ async function uploadManifest(auth, workspaceId, paths, options) {
       const readable = [];
       for (const f2 of batch) {
         try {
-          const blob = readFileAsBlob(f2.absolutePath, f2.size);
+          const blob = readFileAsBlob(f2.absolutePath, f2.size, f2.basename);
           readable.push({ f: f2, blob });
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -6563,7 +6618,6 @@ async function uploadManifest(auth, workspaceId, paths, options) {
         try {
           result = await uploadFiles(
             auth,
-            workspaceId,
             readable.map((r2) => ({ data: r2.blob, name: r2.f.basename })),
             { folder, configExtId: options?.configExtId }
           );
@@ -6677,7 +6731,7 @@ function walkSupportedFiles(dirPath) {
   }
   return out.sort();
 }
-async function uploadArchive(auth, workspaceId, archivePath, options) {
+async function uploadArchive(auth, archivePath, options) {
   try {
     child_process.execSync("7z --help", { stdio: "ignore" });
   } catch {
@@ -6696,7 +6750,7 @@ async function uploadArchive(auth, workspaceId, archivePath, options) {
       fs2__default.default.renameSync(tmpDir, namedDir);
       uploadDir = namedDir;
     }
-    return await uploadDirectory(auth, workspaceId, uploadDir, options);
+    return await uploadDirectory(auth, uploadDir, options);
   } finally {
     fs2__default.default.rmSync(tmpDir, { recursive: true, force: true });
   }