@plyaz/api 1.6.7 → 1.6.8

package/dist/index.cjs

@@ -21623,7 +21623,7 @@ function createOnErrorHandler(handlers, clearTemporaryOverrides2, clearOnComplet
     const apiError = new ApiPackageError(
       "request.failed",
       api.PACKAGE_STATUS_CODES.REQUEST_FAILED,
-      error.status ? `HTTP_${error.status}` : api.API_ERROR_CODES.NETWORK_ERROR,
+      error.status ? errors$1.getErrorCodeByStatus(error.status) ?? api.API_ERROR_CODES.CLIENT_ERROR : api.API_ERROR_CODES.NETWORK_ERROR,
       {
         cause: error,
         context: {
@@ -22249,6 +22249,546 @@ function applyQualityBasedConfiguration(resolvedConfig, quality, networkAware, n
   }
 }
 __name(applyQualityBasedConfiguration, "applyQualityBasedConfiguration");
+var PROGRESS_CHUNK_SIZE_MULTIPLIER = 64;
+var UPLOAD_CONSTANTS = {
+  DEFAULT_CHUNK_SIZE: PROGRESS_CHUNK_SIZE_MULTIPLIER * config.NUMBER_SYSTEM.BYTES_PER_KB,
+  DEFAULT_THROTTLE_MS: config.TIME_CONSTANTS.HUNDRED_MS,
+  DEFAULT_CONTENT_TYPE: "application/octet-stream",
+  DEFAULT_TIMEOUT: config.TIME_CONSTANTS.TWO_MINUTES,
+  DEFAULT_RETRY_DELAY: config.RETRY_DELAYS.SHORT,
+  DEFAULT_RETRY_BACKOFF: config.RETRY_BACKOFF.MEDIUM,
+  DEFAULT_RETRY_MAX_DELAY: config.RETRY_DELAYS.MAX,
+  PROGRESS_PERCENTAGE_THRESHOLD: config.NUMERIC_CONSTANTS.FIVE,
+  FULL_PERCENTAGE: config.MATH_CONSTANTS.PERCENTAGE_MAX,
+  HTTPS_DEFAULT_PORT: config.TIME_CONSTANTS.HTTPS_PORT,
+  HTTP_DEFAULT_PORT: config.TIME_CONSTANTS.HTTP_PORT,
+  /** Max server error status code (exclusive boundary for 5xx range) */
+  MAX_SERVER_ERROR_STATUS: 600
+};
+var RETRYABLE_ERROR_CODES = [
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "ENETUNREACH",
+  "EAI_AGAIN"
+];
+var RETRYABLE_MESSAGE_PATTERNS = [
+  "timeout",
+  "timed out",
+  "network",
+  "econnreset",
+  "econnrefused",
+  "etimedout",
+  "service unavailable",
+  "rate limit",
+  "too many requests"
+];
+
+// src/api/upload/config.ts
+function extractGlobalHeaders(globalConfig) {
+  const globalHeaders = {};
+  if (!globalConfig.headers || typeof globalConfig.headers !== "object") {
+    return globalHeaders;
+  }
+  if (!("presets" in globalConfig.headers) && !("static" in globalConfig.headers)) {
+    Object.entries(globalConfig.headers).forEach(([key, value]) => {
+      if (typeof value === "string") {
+        globalHeaders[key] = value;
+      }
+    });
+    return globalHeaders;
+  }
+  if ("static" in globalConfig.headers) {
+    const staticHeaders = globalConfig.headers.static;
+    if (staticHeaders) {
+      Object.entries(staticHeaders).forEach(([key, value]) => {
+        if (typeof value === "string") {
+          globalHeaders[key] = value;
+        }
+      });
+    }
+  }
+  return globalHeaders;
+}
+__name(extractGlobalHeaders, "extractGlobalHeaders");
+function mergeRetryConfig(optionRetry, globalRetry) {
+  if (optionRetry !== void 0) return optionRetry;
+  if (globalRetry !== void 0) return globalRetry;
+  return false;
+}
+__name(mergeRetryConfig, "mergeRetryConfig");
+function buildLocalConfig(options) {
+  return {
+    headers: options.headers ?? {},
+    timeout: options.timeout ?? UPLOAD_CONSTANTS.DEFAULT_TIMEOUT,
+    baseURL: options.baseURL,
+    retry: options.retry ?? false,
+    onError: options.onError,
+    withCredentials: options.withCredentials ?? false
+  };
+}
+__name(buildLocalConfig, "buildLocalConfig");
+function getMergedConfig(options) {
+  if (options.useGlobalConfig === false) {
+    return buildLocalConfig(options);
+  }
+  const globalConfig = getGlobalConfig();
+  const globalHeaders = extractGlobalHeaders(globalConfig);
+  return {
+    headers: { ...globalHeaders, ...options.headers ?? {} },
+    timeout: options.timeout ?? globalConfig.timeout ?? UPLOAD_CONSTANTS.DEFAULT_TIMEOUT,
+    baseURL: options.baseURL ?? globalConfig.baseURL,
+    retry: mergeRetryConfig(options.retry, globalConfig.retry),
+    onError: options.onError,
+    withCredentials: options.withCredentials ?? globalConfig.withCredentials ?? false
+  };
+}
+__name(getMergedConfig, "getMergedConfig");
+function checkRetryableFlag(error) {
+  if (typeof error.isRetryable === "function") return error.isRetryable();
+  if (typeof error.isRetryable === "boolean") return error.isRetryable;
+  if (typeof error.retryable === "boolean") return error.retryable;
+  return void 0;
+}
+__name(checkRetryableFlag, "checkRetryableFlag");
+function isRetryableStatus(status) {
+  if (status === void 0) return false;
+  if (status === config.HTTP_STATUS.TOO_MANY_REQUESTS) return true;
+  return status >= config.HTTP_STATUS.INTERNAL_SERVER_ERROR && status < UPLOAD_CONSTANTS.MAX_SERVER_ERROR_STATUS;
+}
+__name(isRetryableStatus, "isRetryableStatus");
+function hasRetryableErrorCode(error) {
+  return Boolean(
+    error.code && RETRYABLE_ERROR_CODES.includes(error.code)
+  );
+}
+__name(hasRetryableErrorCode, "hasRetryableErrorCode");
+function hasRetryableMessage(error) {
+  const message = error.message?.toLowerCase() ?? "";
+  return RETRYABLE_MESSAGE_PATTERNS.some((pattern) => message.includes(pattern));
+}
+__name(hasRetryableMessage, "hasRetryableMessage");
+function isRetryableError(error, status) {
+  if (!error) return false;
+  const errorWithRetryable = error;
+  const flagResult = checkRetryableFlag(errorWithRetryable);
+  if (flagResult !== void 0) return flagResult;
+  if (hasRetryableErrorCode(errorWithRetryable)) return true;
+  if (hasRetryableMessage(error)) return true;
+  const httpStatus = status ?? errorWithRetryable.statusCode;
+  return isRetryableStatus(httpStatus);
+}
+__name(isRetryableError, "isRetryableError");
+function calculateRetryDelay(attempt, config) {
+  const delay = config.delay ?? UPLOAD_CONSTANTS.DEFAULT_RETRY_DELAY;
+  const backoff = config.backoff ?? UPLOAD_CONSTANTS.DEFAULT_RETRY_BACKOFF;
+  const maxDelay = config.maxDelay ?? UPLOAD_CONSTANTS.DEFAULT_RETRY_MAX_DELAY;
+  const calculatedDelay = delay * Math.pow(backoff, attempt);
+  return Math.min(calculatedDelay, maxDelay);
+}
+__name(calculateRetryDelay, "calculateRetryDelay");
+function notifyRetryError(params) {
+  const { ctx, message, status, statusText, cause } = params;
+  if (!ctx.config.onError) return;
+  ctx.config.onError({
+    message,
+    status,
+    statusText,
+    cause,
+    retryable: true,
+    attempt: ctx.attempt,
+    maxAttempts: ctx.maxAttempts
+  });
+}
+__name(notifyRetryError, "notifyRetryError");
+function notifyFinalError(ctx, error) {
+  if (!ctx.config.onError) return;
+  ctx.config.onError({
+    message: error.message,
+    cause: error,
+    retryable: false,
+    attempt: ctx.attempt,
+    maxAttempts: ctx.maxAttempts
+  });
+}
+__name(notifyFinalError, "notifyFinalError");
+function shouldRetryResult(result, config, attempt, maxAttempts) {
+  if (result.success) return false;
+  if (!config.retry) return false;
+  if (attempt >= maxAttempts - 1) return false;
+  return isRetryableError(new Error(result.statusText ?? "Upload failed"), result.status);
+}
+__name(shouldRetryResult, "shouldRetryResult");
+function shouldRetryError(error, config, attempt, maxAttempts) {
+  if (!config.retry) return false;
+  if (attempt >= maxAttempts - 1) return false;
+  return isRetryableError(error);
+}
+__name(shouldRetryError, "shouldRetryError");
+async function handleRetryDelay(attempt, config) {
+  await sleep(calculateRetryDelay(attempt, config));
+}
+__name(handleRetryDelay, "handleRetryDelay");
+function resolveUrl(url, baseURL) {
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+  if (!baseURL) {
+    return url;
+  }
+  const base = baseURL.replace(/\/$/, "");
+  const path = url.startsWith("/") ? url : `/${url}`;
+  return `${base}${path}`;
+}
+__name(resolveUrl, "resolveUrl");
+function normalizeData(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  throw new ApiPackageError(
+    "Blob data type is only supported in browser environment",
+    void 0,
+    errors.API_ERROR_CODES.VALIDATION_ERROR
+  );
+}
+__name(normalizeData, "normalizeData");
+function createUploadState(totalSize) {
+  const now2 = Date.now();
+  return {
+    status: "uploading",
+    startTime: now2,
+    bytesUploaded: 0,
+    totalBytes: totalSize,
+    lastProgressTime: now2,
+    lastBytesUploaded: 0
+  };
+}
+__name(createUploadState, "createUploadState");
+function calculateProgress(state) {
+  const now2 = Date.now();
+  const timeDelta = (now2 - state.lastProgressTime) / config.TIME_CONSTANTS.SECOND;
+  const bytesDelta = state.bytesUploaded - state.lastBytesUploaded;
+  const speed = timeDelta > 0 ? bytesDelta / timeDelta : 0;
+  const percentage2 = Math.round(
+    state.bytesUploaded / state.totalBytes * UPLOAD_CONSTANTS.FULL_PERCENTAGE
+  );
+  const remainingBytes = state.totalBytes - state.bytesUploaded;
+  return {
+    loaded: state.bytesUploaded,
+    total: state.totalBytes,
+    percentage: percentage2,
+    speed: speed > 0 ? speed : void 0,
+    estimatedTimeRemaining: speed > 0 ? remainingBytes / speed : void 0
+  };
+}
+__name(calculateProgress, "calculateProgress");
+function emitFinalProgress(onProgress, totalSize, startTime) {
+  if (!onProgress) return;
+  const elapsed = (Date.now() - startTime) / config.TIME_CONSTANTS.SECOND;
+  onProgress({
+    loaded: totalSize,
+    total: totalSize,
+    percentage: UPLOAD_CONSTANTS.FULL_PERCENTAGE,
+    speed: elapsed > 0 ? totalSize / elapsed : void 0,
+    estimatedTimeRemaining: 0
+  });
+}
+__name(emitFinalProgress, "emitFinalProgress");
+function shouldEmitProgress(state, totalSize, throttleMs) {
+  const now2 = Date.now();
+  const timeSinceLastProgress = now2 - state.lastProgressTime;
+  const currentPct = Math.round(
+    state.bytesUploaded / totalSize * UPLOAD_CONSTANTS.FULL_PERCENTAGE
+  );
+  const lastPct = Math.round(
+    state.lastBytesUploaded / totalSize * UPLOAD_CONSTANTS.FULL_PERCENTAGE
+  );
+  return timeSinceLastProgress >= throttleMs || currentPct - lastPct >= UPLOAD_CONSTANTS.PROGRESS_PERCENTAGE_THRESHOLD;
+}
+__name(shouldEmitProgress, "shouldEmitProgress");
+function parseNodeHeaders(headers2) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers2)) {
+    if (value !== void 0) {
+      result[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+  }
+  return result;
+}
+__name(parseNodeHeaders, "parseNodeHeaders");
+
+// src/api/upload/node.ts
+var createTimeoutError = /* @__PURE__ */ __name((url) => new ApiPackageError("Upload timed out", void 0, errors.API_ERROR_CODES.REQUEST_TIMEOUT, {
+  context: { url }
+}), "createTimeoutError");
+var createAbortError = /* @__PURE__ */ __name((url) => new ApiPackageError("Upload aborted", void 0, errors.API_ERROR_CODES.REQUEST_ABORTED, {
+  context: { url }
+}), "createAbortError");
+var normalizeError = /* @__PURE__ */ __name((error) => error instanceof Error ? error : new ApiPackageError(String(error), void 0, errors.API_ERROR_CODES.UNKNOWN_ERROR), "normalizeError");
+async function uploadOnce(options, config$1, resolvedUrl) {
+  const {
+    data,
+    method = "PUT",
+    contentType = UPLOAD_CONSTANTS.DEFAULT_CONTENT_TYPE,
+    onProgress,
+    abortSignal
+  } = options;
+  const chunkSize = options.chunkSize ?? UPLOAD_CONSTANTS.DEFAULT_CHUNK_SIZE;
+  const throttleMs = options.throttleMs ?? UPLOAD_CONSTANTS.DEFAULT_THROTTLE_MS;
+  const { headers: mergedHeaders, timeout } = config$1;
+  const buffer = normalizeData(data);
+  const totalSize = buffer.length;
+  const parsedUrl = new URL(resolvedUrl);
+  const isHttps = parsedUrl.protocol === "https:";
+  const httpModule = await (isHttps ? import('https') : import('http'));
+  const state = createUploadState(totalSize);
+  return new Promise((resolve, reject) => {
+    let timeoutId;
+    if (timeout > 0) timeoutId = setTimeout(() => reject(createTimeoutError(resolvedUrl)), timeout);
+    const clearUploadTimeout = /* @__PURE__ */ __name(() => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+    }, "clearUploadTimeout");
+    onProgress?.({ loaded: 0, total: totalSize, percentage: 0 });
+    const requestOptions = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (isHttps ? UPLOAD_CONSTANTS.HTTPS_DEFAULT_PORT : UPLOAD_CONSTANTS.HTTP_DEFAULT_PORT),
+      path: parsedUrl.pathname + parsedUrl.search,
+      method,
+      headers: {
+        "Content-Type": contentType,
+        "Content-Length": totalSize.toString(),
+        ...mergedHeaders
+      }
+    };
+    const req = httpModule.request(requestOptions, (res) => {
+      let responseData = "";
+      res.on("data", (chunk) => {
+        responseData += chunk;
+      });
+      res.on("end", () => {
+        clearUploadTimeout();
+        const success = res.statusCode !== void 0 && res.statusCode >= config.HTTP_STATUS.OK && res.statusCode < config.HTTP_STATUS.MULTIPLE_CHOICES;
+        if (success) emitFinalProgress(onProgress, totalSize, state.startTime);
+        resolve({
+          status: res.statusCode ?? 0,
+          statusText: res.statusMessage ?? "",
+          data: responseData || void 0,
+          headers: parseNodeHeaders(res.headers),
+          success
+        });
+      });
+    });
+    if (abortSignal)
+      abortSignal.addEventListener("abort", () => {
+        clearUploadTimeout();
+        req.destroy();
+        state.status = "aborted";
+        reject(createAbortError(resolvedUrl));
+      });
+    req.on("error", (error) => {
+      clearUploadTimeout();
+      state.status = "failed";
+      state.error = error;
+      reject(error);
+    });
+    let offset = 0;
+    const writeNextChunk = /* @__PURE__ */ __name(() => {
+      while (offset < totalSize) {
+        const end = Math.min(offset + chunkSize, totalSize);
+        const canContinue = req.write(buffer.subarray(offset, end));
+        state.bytesUploaded = end;
+        offset = end;
+        if (onProgress && shouldEmitProgress(state, totalSize, throttleMs)) {
+          onProgress(calculateProgress(state));
+          state.lastProgressTime = Date.now();
+          state.lastBytesUploaded = state.bytesUploaded;
+        }
+        if (!canContinue) {
+          req.once("drain", writeNextChunk);
+          return;
+        }
+      }
+      state.status = "completed";
+      req.end();
+    }, "writeNextChunk");
+    writeNextChunk();
+  });
+}
+__name(uploadOnce, "uploadOnce");
+async function uploadWithProgressNode(options) {
+  const config = getMergedConfig(options);
+  const resolvedUrl = resolveUrl(options.url, config.baseURL);
+  const maxAttempts = config.retry ? (config.retry.attempts ?? 0) + 1 : 1;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const ctx = { config, maxAttempts, attempt };
+    try {
+      const result = await uploadOnce(options, config, resolvedUrl);
+      if (shouldRetryResult(result, config, attempt, maxAttempts)) {
+        notifyRetryError({
+          ctx,
+          message: `Upload failed: ${result.status}`,
+          status: result.status,
+          statusText: result.statusText
+        });
+        await handleRetryDelay(attempt, config.retry);
+        continue;
+      }
+      return { ...result, attempts: attempt };
+    } catch (error) {
+      lastError = normalizeError(error);
+      if (shouldRetryError(lastError, config, attempt, maxAttempts)) {
+        notifyRetryError({ ctx, message: lastError.message, cause: lastError });
+        await handleRetryDelay(attempt, config.retry);
+        continue;
+      }
+      notifyFinalError(ctx, lastError);
+      throw lastError;
+    }
+  }
+  throw lastError ?? new ApiPackageError(
+    "Upload failed after all retry attempts",
+    void 0,
+    errors.API_ERROR_CODES.NETWORK_ERROR
+  );
+}
+__name(uploadWithProgressNode, "uploadWithProgressNode");
+var normalizeError2 = /* @__PURE__ */ __name((error) => error instanceof Error ? error : new ApiPackageError(String(error), void 0, errors.API_ERROR_CODES.UNKNOWN_ERROR), "normalizeError");
+async function uploadOnce2(options, config$1, resolvedUrl) {
+  const {
+    data,
+    method = "PUT",
+    contentType = UPLOAD_CONSTANTS.DEFAULT_CONTENT_TYPE,
+    onProgress,
+    abortSignal
+  } = options;
+  const { headers: mergedHeaders, timeout, withCredentials } = config$1;
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    const startTime = Date.now();
+    if (timeout > 0) xhr.timeout = timeout;
+    xhr.addEventListener(
+      "timeout",
+      () => reject(
+        new ApiPackageError("Upload timed out", void 0, errors.API_ERROR_CODES.REQUEST_TIMEOUT, {
+          context: { url: resolvedUrl }
+        })
+      )
+    );
+    xhr.upload.addEventListener("progress", (event) => {
+      if (!event.lengthComputable || !onProgress) return;
+      const elapsed = (Date.now() - startTime) / config.TIME_CONSTANTS.SECOND;
+      const speed = elapsed > 0 ? event.loaded / elapsed : 0;
+      const remaining = event.total - event.loaded;
+      onProgress({
+        loaded: event.loaded,
+        total: event.total,
+        percentage: Math.round(event.loaded / event.total * UPLOAD_CONSTANTS.FULL_PERCENTAGE),
+        speed,
+        estimatedTimeRemaining: speed > 0 ? remaining / speed : void 0
+      });
+    });
+    xhr.addEventListener("load", () => {
+      const success = xhr.status >= config.HTTP_STATUS.OK && xhr.status < config.HTTP_STATUS.MULTIPLE_CHOICES;
+      const responseHeaders = {};
+      const headerLines = xhr.getAllResponseHeaders().trim().split("\n");
+      for (const line of headerLines) {
+        const [key, ...valueParts] = line.split(":");
+        if (key) responseHeaders[key.trim().toLowerCase()] = valueParts.join(":").trim();
+      }
+      resolve({
+        status: xhr.status,
+        statusText: xhr.statusText,
+        data: xhr.responseText || void 0,
+        headers: responseHeaders,
+        success
+      });
+    });
+    xhr.addEventListener(
+      "error",
+      () => reject(
+        new ApiPackageError(
+          `Upload failed: ${xhr.statusText || "Network error"}`,
+          void 0,
+          errors.API_ERROR_CODES.NETWORK_ERROR,
+          { context: { url: resolvedUrl, statusText: xhr.statusText } }
+        )
+      )
+    );
+    xhr.addEventListener(
+      "abort",
+      () => reject(
+        new ApiPackageError("Upload aborted", void 0, errors.API_ERROR_CODES.REQUEST_ABORTED, {
+          context: { url: resolvedUrl }
+        })
+      )
+    );
+    if (abortSignal) abortSignal.addEventListener("abort", () => xhr.abort());
+    xhr.open(method, resolvedUrl);
+    if (withCredentials) xhr.withCredentials = true;
+    xhr.setRequestHeader("Content-Type", contentType);
+    for (const [key, value] of Object.entries(mergedHeaders)) xhr.setRequestHeader(key, value);
+    if (data instanceof Blob || data instanceof ArrayBuffer) {
+      xhr.send(data);
+    } else if (data instanceof Uint8Array) {
+      xhr.send(new Uint8Array(data));
+    } else {
+      xhr.send(data);
+    }
+  });
+}
+__name(uploadOnce2, "uploadOnce");
+async function uploadWithProgressBrowser(options) {
+  const config = getMergedConfig(options);
+  const resolvedUrl = resolveUrl(options.url, config.baseURL);
+  const maxAttempts = config.retry ? (config.retry.attempts ?? 0) + 1 : 1;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const ctx = { config, maxAttempts, attempt };
+    try {
+      const result = await uploadOnce2(options, config, resolvedUrl);
+      if (shouldRetryResult(result, config, attempt, maxAttempts)) {
+        notifyRetryError({
+          ctx,
+          message: `Upload failed: ${result.status}`,
+          status: result.status,
+          statusText: result.statusText
+        });
+        await handleRetryDelay(attempt, config.retry);
+        continue;
+      }
+      return { ...result, attempts: attempt };
+    } catch (error) {
+      lastError = normalizeError2(error);
+      if (shouldRetryError(lastError, config, attempt, maxAttempts)) {
+        notifyRetryError({ ctx, message: lastError.message, cause: lastError });
+        await handleRetryDelay(attempt, config.retry);
+        continue;
+      }
+      notifyFinalError(ctx, lastError);
+      throw lastError;
+    }
+  }
+  throw lastError ?? new ApiPackageError(
+    "Upload failed after all retry attempts",
+    void 0,
+    errors.API_ERROR_CODES.NETWORK_ERROR
+  );
+}
+__name(uploadWithProgressBrowser, "uploadWithProgressBrowser");
+
+// src/api/upload/uploadWithProgress.ts
+async function uploadWithProgress(options) {
+  if (isNode()) {
+    return uploadWithProgressNode(options);
+  }
+  return uploadWithProgressBrowser(options);
+}
+__name(uploadWithProgress, "uploadWithProgress");
 
 // src/api/hooks/factories/defaults.ts
 var DEFAULT_QUERY_OPTIONS = {};
@@ -24396,13 +24936,13 @@ function isAbortError(error) {
   return message.includes("abort") || message.includes("cancel");
 }
 __name(isAbortError, "isAbortError");
-function createAbortError(message = "Request aborted") {
+function createAbortError2(message = "Request aborted") {
   if (message === null || message === void 0) {
     return "Request aborted";
   }
   return message;
 }
-__name(createAbortError, "createAbortError");
+__name(createAbortError2, "createAbortError");
 
 // src/api/request/tracker.ts
 var RequestTracker = class {
@@ -24452,7 +24992,7 @@ var RequestTracker = class {
       controller.abort(reason);
       this.unregister(key);
     }
-    void abortRequest(key, createAbortError(reason ?? "Request aborted"));
+    void abortRequest(key, createAbortError2(reason ?? "Request aborted"));
   }
   /**
    * Abort all requests in a group
@@ -24478,7 +25018,7 @@ var RequestTracker = class {
     });
     this.activeRequests.clear();
     this.requestGroups.clear();
-    void abortRequest("*", createAbortError(reason ?? "All requests aborted"));
+    void abortRequest("*", createAbortError2(reason ?? "All requests aborted"));
   }
   /**
    * Get active request count
@@ -24535,14 +25075,14 @@ function useRequestCleanup() {
   }, "untrackRequest");
   const abortTracked = /* @__PURE__ */ __name((reason) => {
     requestKeys.current.forEach((key) => {
-      void abortRequest(key, createAbortError(reason ?? "Manual abort"));
+      void abortRequest(key, createAbortError2(reason ?? "Manual abort"));
     });
     requestKeys.current.clear();
   }, "abortTracked");
   react.useEffect(() => {
     return () => {
       requestKeys.current.forEach((key) => {
-        void abortRequest(key, createAbortError("Component unmounted"));
+        void abortRequest(key, createAbortError2("Component unmounted"));
       });
       requestKeys.current.clear();
     };
@@ -24563,14 +25103,14 @@ function useAbortableRequest(key) {
         controllerRef.current.abort("Component unmounted or dependency changed");
         requestTracker.unregister(key);
       }
-      void abortRequest(key, createAbortError("Request cancelled"));
+      void abortRequest(key, createAbortError2("Request cancelled"));
     };
   }, [key]);
   const abort = /* @__PURE__ */ __name((reason) => {
     if (controllerRef.current) {
       controllerRef.current.abort(reason);
     }
-    void abortRequest(key, createAbortError(reason ?? "Request aborted by user"));
+    void abortRequest(key, createAbortError2(reason ?? "Request aborted by user"));
   }, "abort");
   return {
     signal,
@@ -24632,9 +25172,9 @@ function setupRouteChangeCleanup(router, options = {}) {
       }
       const pattern = options.abortPattern ?? "*";
       if (options.preservePatterns && options.preservePatterns.length > 0) {
-        void abortRequest(pattern, createAbortError(`Route changed to ${url}`));
+        void abortRequest(pattern, createAbortError2(`Route changed to ${url}`));
       } else {
-        void abortRequest(pattern, createAbortError(`Route changed to ${url}`));
+        void abortRequest(pattern, createAbortError2(`Route changed to ${url}`));
       }
     }, "executeAbort");
     if (options.delay && options.delay > 0) {
@@ -24681,7 +25221,7 @@ function createRouteGuard(pattern = "*") {
     }, "enter"),
     leave: /* @__PURE__ */ __name((reason) => {
       if (isActive) {
-        void abortRequest(pattern, createAbortError(reason ?? "Leaving route"));
+        void abortRequest(pattern, createAbortError2(reason ?? "Leaving route"));
         isActive = false;
       }
     }, "leave"),
@@ -24713,7 +25253,7 @@ __name(createRouteScope, "createRouteScope");
 
 // src/api/request/utils.ts
 function abortByPattern(pattern, reason) {
-  void abortRequest(pattern, createAbortError(reason ?? `Requests matching ${pattern} aborted`));
+  void abortRequest(pattern, createAbortError2(reason ?? `Requests matching ${pattern} aborted`));
 }
 __name(abortByPattern, "abortByPattern");
 function abortSearchRequests(reason) {
@@ -24731,25 +25271,25 @@ __name(abortAllRequests, "abortAllRequests");
 function createScopedAbort(scope) {
   return (key, reason) => {
     const fullKey = key.startsWith("/") ? `${scope}${key}` : `${scope}/${key}`;
-    void abortRequest(fullKey, createAbortError(reason ?? "Scoped request aborted"));
+    void abortRequest(fullKey, createAbortError2(reason ?? "Scoped request aborted"));
   };
 }
 __name(createScopedAbort, "createScopedAbort");
 function createDebouncedAbort(delay = 300) {
   return debounce((key, reason) => {
-    void abortRequest(key, createAbortError(reason ?? "Debounced abort"));
+    void abortRequest(key, createAbortError2(reason ?? "Debounced abort"));
   }, delay);
 }
 __name(createDebouncedAbort, "createDebouncedAbort");
 function createThrottledAbort(limit = 1e3) {
   return throttle((key, reason) => {
-    void abortRequest(key, createAbortError(reason ?? "Throttled abort"));
+    void abortRequest(key, createAbortError2(reason ?? "Throttled abort"));
   }, limit);
 }
 __name(createThrottledAbort, "createThrottledAbort");
 async function requestWithTimeout(key, fetcher, timeoutMs) {
   const timeoutId = setTimeout(() => {
-    void abortRequest(key, createAbortError(`Request timeout after ${timeoutMs}ms`));
+    void abortRequest(key, createAbortError2(`Request timeout after ${timeoutMs}ms`));
   }, timeoutMs);
   try {
     return await fetcher();
@@ -24762,7 +25302,7 @@ async function raceRequests(requests) {
   const abortLosers = /* @__PURE__ */ __name((winnerKey) => {
     requests.forEach((req) => {
       if (req.key !== winnerKey) {
-        void abortRequest(req.key, createAbortError("Lost race"));
+        void abortRequest(req.key, createAbortError2("Lost race"));
       }
     });
   }, "abortLosers");
@@ -24783,7 +25323,7 @@ async function sequentialRequests(requests) {
       results.push(result);
     } catch (error) {
       for (let j = i + 1; j < requests.length; j++) {
-        void abortRequest(requests[j].key, createAbortError("Previous request in chain failed"));
+        void abortRequest(requests[j].key, createAbortError2("Previous request in chain failed"));
       }
       throw error;
     }
@@ -27039,7 +27579,7 @@ exports.configConflictDetector = configConflictDetector;
 exports.configureForEnvironment = configureForEnvironment;
 exports.containsAny = containsAny;
 exports.convertEndpointsToFetchff = convertEndpointsToFetchff;
-exports.createAbortError = createAbortError;
+exports.createAbortError = createAbortError2;
 exports.createAdaptiveResponse = createAdaptiveResponse;
 exports.createApiClient = createApiClient;
 exports.createCachePattern = createCachePattern;
@@ -27490,6 +28030,7 @@ exports.updateInfobipScheduledEmailStatuses = updateInfobipScheduledEmailStatuse
 exports.uploadFile = uploadFile;
 exports.uploadFileForScanning = uploadFileForScanning;
 exports.uploadFiles = uploadFiles;
+exports.uploadWithProgress = uploadWithProgress;
 exports.useAbortableRequest = useAbortableRequest;
 exports.useApiConfigConflicts = useApiConfigConflicts;
 exports.useApiDebugInfo = useApiDebugInfo;