@arbidocs/client 0.5.57 → 0.5.58

package/dist/index.cjs

@@ -10,6 +10,60 @@ var sodium__default = /*#__PURE__*/_interopDefault(sodium);
 
 // src/client.ts
 
+// src/http-transport.ts
+function createHttpTransport(options = {}) {
+  const { timeoutMs } = options;
+  if (timeoutMs !== void 0 && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+    throw new RangeError("transport.timeoutMs must be a positive finite number.");
+  }
+  const wrap = (adapter2) => async (input, init) => {
+    const url = new URL(input instanceof Request ? input.url : String(input), "http://localhost");
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    const info = {
+      method: (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase(),
+      url: url.toString()
+    };
+    options.onRequest?.(info);
+    const started = performance.now();
+    let timer;
+    let requestInit = init;
+    if (timeoutMs !== void 0) {
+      const controller = new AbortController();
+      const own = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+      timer = setTimeout(
+        () => controller.abort(
+          new DOMException("Waiting for HTTP response timed out.", "TimeoutError")
+        ),
+        timeoutMs
+      );
+      requestInit = {
+        ...init,
+        signal: own ? AbortSignal.any([own, controller.signal]) : controller.signal
+      };
+    }
+    let response;
+    try {
+      response = await adapter2(input, requestInit);
+    } catch (error) {
+      options.onError?.({ ...info, error, durationMs: performance.now() - started });
+      throw error;
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+    options.onResponse?.({
+      ...info,
+      status: response.status,
+      durationMs: performance.now() - started
+    });
+    return response;
+  };
+  const adapter = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  return { fetch: wrap(adapter), customFetch: options.fetch !== void 0, withFetch: wrap };
+}
+
 // src/session.ts
 function createInitialState(isSsoMode = false) {
   return {
@@ -1161,11 +1215,11 @@ function createSessionGate() {
     }
   };
 }
-function gatedFetch(gate, fetch2) {
+function gatedFetch(gate, fetch) {
   return (input, init) => {
     if (gate.closed) return Promise.reject(abortError());
     const own = init?.signal ?? (input instanceof Request ? input.signal : void 0);
-    return fetch2(input, { ...init, signal: eitherSignal(gate.signal, own) });
+    return fetch(input, { ...init, signal: eitherSignal(gate.signal, own) });
   };
 }
 function createSessionGateMiddleware(gate) {
@@ -1379,7 +1433,7 @@ function createAutoReloginMiddleware(config) {
         if (workspaceId) {
           if (!await config.primeWorkspaceHandler(workspaceId)) return response;
           const retry = cloneCache.get(request) ?? safeClone(request);
-          if (retry) return fetch(retry);
+          if (retry) return (config.fetch ?? globalThis.fetch)(retry);
           config.onRetryCloneFailed?.();
           return response;
         }
@@ -1395,7 +1449,7 @@ function createAutoReloginMiddleware(config) {
         const retry = cloneCache.get(request) ?? safeClone(request);
         if (retry) {
           if (token) retry.headers.set("Authorization", `Bearer ${token}`);
-          return fetch(retry);
+          return (config.fetch ?? globalThis.fetch)(retry);
         }
         config.onRetryCloneFailed?.();
         return response;
@@ -1407,7 +1461,7 @@ function createAutoReloginMiddleware(config) {
           if (newToken) {
             const retryRequest = cloneCache.get(request) ?? request.clone();
             retryRequest.headers.set("Authorization", `Bearer ${newToken}`);
-            return fetch(retryRequest);
+            return (config.fetch ?? globalThis.fetch)(retryRequest);
           }
         }
       }
@@ -1420,12 +1474,12 @@ function createAutoReloginMiddleware(config) {
             const cached = cloneCache.get(request);
             if (cached) {
               cached.headers.set("Authorization", `Bearer ${newToken}`);
-              return fetch(cached);
+              return (config.fetch ?? globalThis.fetch)(cached);
             }
             try {
               const retryRequest = request.clone();
               retryRequest.headers.set("Authorization", `Bearer ${newToken}`);
-              return fetch(retryRequest);
+              return (config.fetch ?? globalThis.fetch)(retryRequest);
             } catch {
               console.warn("[API] Could not retry request after re-login (body already consumed)");
               config.onRetryCloneFailed?.();
@@ -1874,22 +1928,26 @@ var RETRYABLE_CODES = /* @__PURE__ */ new Set([
 var MAX_RETRIES = 3;
 var BASE_DELAY_MS = 200;
 function isRetryableError(err) {
-  if (!(err instanceof Error)) return false;
+  if (!(err instanceof Error) || isAbortError(err)) return false;
   const cause = err.cause;
   if (cause?.code && RETRYABLE_CODES.has(cause.code)) return true;
   const msg = err.message || "";
   return RETRYABLE_CODES.has(msg) || msg.includes("ECONNREFUSED") || msg.includes("ECONNRESET");
 }
-function createRetryFetch() {
+function createRetryFetch(fetch) {
   return async (input, init) => {
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+    const maxRetries = method === "GET" || method === "HEAD" ? MAX_RETRIES : 0;
+    const signal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
     let lastError;
-    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (signal?.aborted) throw signal.reason ?? new DOMException("Request aborted.", "AbortError");
       try {
         const fetchInput = input instanceof Request ? input.clone() : input;
-        return await globalThis.fetch(fetchInput, init);
+        return await fetch(fetchInput, init);
       } catch (err) {
         lastError = err;
-        if (attempt < MAX_RETRIES && isRetryableError(err)) {
+        if (attempt < maxRetries && isRetryableError(err)) {
           await new Promise((r) => setTimeout(r, BASE_DELAY_MS * 2 ** attempt));
           continue;
         }
@@ -1911,9 +1969,9 @@ function readBaseUrlPerRequest(fetchClient, base) {
 }
 var deploymentDomainOf = ({ deploymentDomain }) => typeof deploymentDomain === "function" ? deploymentDomain() : deploymentDomain;
 function createArbiClient(options) {
-  const { fetch: fetch2, session, persistence, workspaceKeys, workspaceOpens, auth } = createTransport(options);
+  const { fetch, http, session, persistence, workspaceKeys, workspaceOpens, auth } = createTransport(options);
   const authDeps = {
-    fetchClient: fetch2,
+    fetchClient: fetch,
     session,
     get deploymentDomain() {
       return deploymentDomainOf(options);
@@ -1922,7 +1980,8 @@ function createArbiClient(options) {
     signIn: options.signIn
   };
   return {
-    fetch: fetch2,
+    fetch,
+    http,
     workspaceKeys,
     workspaceOpens,
     session,
@@ -1972,9 +2031,15 @@ function createTransport(options) {
   const persistence = options.persistence ?? { getSession, saveSession };
   const baseUrlOption = options.baseUrl;
   const base = typeof baseUrlOption === "function" ? baseUrlOption : () => baseUrlOption;
-  const retryFetch = createRetryFetch();
+  const transport = createHttpTransport(options.transport);
+  const retryFetch = createRetryFetch(transport.fetch);
   const gate = createSessionGate();
   const sessionFetch = gatedFetch(gate, retryFetch);
+  const http = {
+    fetch: gatedFetch(gate, transport.fetch),
+    customFetch: transport.customFetch,
+    withFetch: (adapter) => gatedFetch(gate, transport.withFetch(adapter))
+  };
   const session = options.session ?? createSessionManager();
   if (userEmail) session.setUser(userEmail);
   const tokenProvider = createTokenProvider(session);
@@ -2171,6 +2236,7 @@ function createTransport(options) {
   for (const m of middleware) fetchClient.use(m);
   fetchClient.use(
     createAutoReloginMiddleware({
+      fetch: sessionFetch,
       reloginHandler: relogin,
       reloginExcludePatterns,
       reopenWorkspaceHandler: reopenWorkspace,
@@ -2186,6 +2252,7 @@ function createTransport(options) {
   );
   return {
     fetch: fetchClient,
+    http,
     session,
     persistence,
     workspaceKeys,
@@ -2336,6 +2403,7 @@ exports.createAuthMessage = createAuthMessage;
 exports.createAutoReloginMiddleware = createAutoReloginMiddleware;
 exports.createBearerAuthMiddleware = createBearerAuthMiddleware;
 exports.createContentHash = createContentHash;
+exports.createHttpTransport = createHttpTransport;
 exports.createOfflineSealer = createOfflineSealer;
 exports.createRecoveryFile = createRecoveryFile;
 exports.createRecoveryUrl = createRecoveryUrl;