@zayne-labs/callapi 1.7.2 → 1.7.4

package/dist/cjs/index.cjs

@@ -29,118 +29,35 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/error.ts
-var resolveErrorResult = (info) => {
-  const { cloneResponse, defaultErrorMessage, error, message: customErrorMessage, resultMode } = info;
-  let apiDetails = {
-    data: null,
-    error: {
-      errorData: error,
-      message: customErrorMessage ?? error.message,
-      name: error.name
-    },
-    response: null
-  };
-  if (isHTTPErrorInstance(error)) {
-    const { errorData, message = defaultErrorMessage, name, response } = error;
-    apiDetails = {
-      data: null,
-      error: {
-        errorData,
-        message,
-        name
-      },
-      response: cloneResponse ? response.clone() : response
-    };
-  }
-  const resultModeMap = {
-    all: apiDetails,
-    allWithException: apiDetails,
-    allWithoutResponse: omitKeys(apiDetails, ["response"]),
-    onlyError: apiDetails.error,
-    onlyResponse: apiDetails.response,
-    onlyResponseWithException: apiDetails.response,
-    onlySuccess: apiDetails.data,
-    onlySuccessWithException: apiDetails.data
-  };
-  const getErrorResult = (customErrorInfo) => {
-    const errorVariantResult = resultModeMap[resultMode ?? "all"];
-    return customErrorInfo ? {
-      ...errorVariantResult,
-      error: {
-        ...errorVariantResult.error,
-        ...customErrorInfo
+// src/hooks.ts
+var hookRegistries = {
+  onError: /* @__PURE__ */ new Set(),
+  onRequest: /* @__PURE__ */ new Set(),
+  onRequestError: /* @__PURE__ */ new Set(),
+  onRequestStream: /* @__PURE__ */ new Set(),
+  onResponse: /* @__PURE__ */ new Set(),
+  onResponseError: /* @__PURE__ */ new Set(),
+  onResponseStream: /* @__PURE__ */ new Set(),
+  onRetry: /* @__PURE__ */ new Set(),
+  onSuccess: /* @__PURE__ */ new Set()
+};
+var composeTwoHooks = (hooks, mergedHooksExecutionMode) => {
+  if (hooks.length === 0) return;
+  const mergedHook = async (ctx) => {
+    if (mergedHooksExecutionMode === "sequential") {
+      for (const hook of hooks) {
+        await hook?.(ctx);
       }
-    } : errorVariantResult;
+      return;
+    }
+    if (mergedHooksExecutionMode === "parallel") {
+      const hookArray = [...hooks];
+      await Promise.all(hookArray.map((uniqueHook) => uniqueHook?.(ctx)));
+    }
   };
-  return { apiDetails, getErrorResult };
-};
-var HTTPError = class extends Error {
-  errorData;
-  isHTTPError = true;
-  name = "HTTPError";
-  response;
-  constructor(errorDetails, errorOptions) {
-    const { defaultErrorMessage, errorData, response } = errorDetails;
-    super(errorData?.message ?? defaultErrorMessage, errorOptions);
-    this.errorData = errorData;
-    this.response = response;
-    Error.captureStackTrace(this, this.constructor);
-  }
-};
-
-// src/utils/guards.ts
-var isHTTPErrorInstance = (error) => {
-  return (
-    // prettier-ignore
-    error instanceof HTTPError || isPlainObject(error) && error.name === "HTTPError" && error.isHTTPError === true
-  );
-};
-var isArray = (value) => Array.isArray(value);
-var isObject = (value) => typeof value === "object" && value !== null;
-var hasObjectPrototype = (value) => {
-  return Object.prototype.toString.call(value) === "[object Object]";
-};
-var isPlainObject = (value) => {
-  if (!hasObjectPrototype(value)) {
-    return false;
-  }
-  const constructor = value?.constructor;
-  if (constructor === void 0) {
-    return true;
-  }
-  const prototype = constructor.prototype;
-  if (!hasObjectPrototype(prototype)) {
-    return false;
-  }
-  if (!Object.hasOwn(prototype, "isPrototypeOf")) {
-    return false;
-  }
-  if (Object.getPrototypeOf(value) !== Object.prototype) {
-    return false;
-  }
-  return true;
-};
-var isJsonString = (value) => {
-  if (!isString(value)) {
-    return false;
-  }
-  try {
-    JSON.parse(value);
-    return true;
-  } catch {
-    return false;
-  }
-};
-var isSerializable = (value) => {
-  return isPlainObject(value) || isArray(value) || typeof value?.toJSON === "function";
-};
-var isFunction = (value) => typeof value === "function";
-var isQueryString = (value) => isString(value) && value.includes("=");
-var isString = (value) => typeof value === "string";
-var isReadableStream = (value) => {
-  return value instanceof ReadableStream;
+  return mergedHook;
 };
+var executeHooks = (...hooks) => Promise.all(hooks);
 
 // src/auth.ts
 var getValue = (value) => {
@@ -183,8 +100,7 @@ var getAuthHeader = (auth) => {
 var defineEnum = (value) => value;
 
 // src/types/common.ts
-var optionsEnumToExtendFromBase = defineEnum(["plugins", "validators", "schemas"]);
-var optionsEnumToOmitFromBase = defineEnum(["extend", "dedupeKey"]);
+var optionsEnumToOmitFromBase = defineEnum(["dedupeKey"]);
 
 // src/utils/constants.ts
 var fetchSpecificKeys = defineEnum([
@@ -301,12 +217,6 @@ var mergeAndResolveHeaders = (options) => {
   }
   return headersObject;
 };
-var combineHooks = (baseInterceptor, interceptor) => {
-  if (isArray(baseInterceptor)) {
-    return [baseInterceptor, interceptor].flat();
-  }
-  return interceptor ?? baseInterceptor;
-};
 var getFetchImpl = (customFetchImpl) => {
   if (customFetchImpl) {
     return customFetchImpl;
@@ -316,7 +226,6 @@ var getFetchImpl = (customFetchImpl) => {
   }
   throw new Error("No fetch implementation found");
 };
-var executeHooks = (...interceptors) => Promise.all(interceptors);
 var PromiseWithResolvers = () => {
   let reject;
   let resolve;
@@ -332,6 +241,124 @@ var waitUntil = (delay) => {
   setTimeout(resolve, delay);
   return promise;
 };
+var createCombinedSignal = (...signals) => AbortSignal.any(signals.filter(Boolean));
+var createTimeoutSignal = (milliseconds) => AbortSignal.timeout(milliseconds);
+
+// src/error.ts
+var resolveErrorResult = (info) => {
+  const { cloneResponse, defaultErrorMessage, error, message: customErrorMessage, resultMode } = info;
+  let apiDetails = {
+    data: null,
+    error: {
+      errorData: error,
+      message: customErrorMessage ?? error.message,
+      name: error.name
+    },
+    response: null
+  };
+  if (isHTTPErrorInstance(error)) {
+    const { errorData, message = defaultErrorMessage, name, response } = error;
+    apiDetails = {
+      data: null,
+      error: {
+        errorData,
+        message,
+        name
+      },
+      response: cloneResponse ? response.clone() : response
+    };
+  }
+  const resultModeMap = {
+    all: apiDetails,
+    allWithException: apiDetails,
+    allWithoutResponse: omitKeys(apiDetails, ["response"]),
+    onlyError: apiDetails.error,
+    onlyResponse: apiDetails.response,
+    onlyResponseWithException: apiDetails.response,
+    onlySuccess: apiDetails.data,
+    onlySuccessWithException: apiDetails.data
+  };
+  const getErrorResult = (customErrorInfo) => {
+    const errorVariantResult = resultModeMap[resultMode ?? "all"];
+    return customErrorInfo ? {
+      ...errorVariantResult,
+      error: {
+        ...errorVariantResult.error,
+        ...customErrorInfo
+      }
+    } : errorVariantResult;
+  };
+  return { apiDetails, getErrorResult };
+};
+var HTTPError = class {
+  cause;
+  errorData;
+  isHTTPError = true;
+  message;
+  name = "HTTPError";
+  response;
+  constructor(errorDetails, errorOptions) {
+    const { defaultErrorMessage, errorData, response } = errorDetails;
+    this.message = errorData?.message ?? defaultErrorMessage;
+    errorOptions?.cause && (this.cause = errorOptions.cause);
+    this.errorData = errorData;
+    this.response = response;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+
+// src/utils/guards.ts
+var isHTTPErrorInstance = (error) => {
+  return (
+    // prettier-ignore
+    error instanceof HTTPError || isPlainObject(error) && error.name === "HTTPError" && error.isHTTPError === true
+  );
+};
+var isArray = (value) => Array.isArray(value);
+var isObject = (value) => typeof value === "object" && value !== null;
+var hasObjectPrototype = (value) => {
+  return Object.prototype.toString.call(value) === "[object Object]";
+};
+var isPlainObject = (value) => {
+  if (!hasObjectPrototype(value)) {
+    return false;
+  }
+  const constructor = value?.constructor;
+  if (constructor === void 0) {
+    return true;
+  }
+  const prototype = constructor.prototype;
+  if (!hasObjectPrototype(prototype)) {
+    return false;
+  }
+  if (!Object.hasOwn(prototype, "isPrototypeOf")) {
+    return false;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype) {
+    return false;
+  }
+  return true;
+};
+var isJsonString = (value) => {
+  if (!isString(value)) {
+    return false;
+  }
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isSerializable = (value) => {
+  return isPlainObject(value) || isArray(value) || typeof value?.toJSON === "function";
+};
+var isFunction = (value) => typeof value === "function";
+var isQueryString = (value) => isString(value) && value.includes("=");
+var isString = (value) => typeof value === "string";
+var isReadableStream = (value) => {
+  return value instanceof ReadableStream;
+};
 
 // src/stream.ts
 var createProgressEvent = (options) => {
@@ -354,17 +381,19 @@ var calculateTotalBytesFromBody = async (requestBody, existingTotalBytes) => {
   return totalBytes;
 };
 var toStreamableRequest = async (context) => {
-  const { options, request, requestInstance } = context;
+  const { baseConfig, config, options, request, requestInstance } = context;
   if (!options.onRequestStream || !requestInstance.body) return;
   const contentLength = requestInstance.headers.get("content-length") ?? new Headers(request.headers).get("content-length") ?? request.body?.size;
   let totalBytes = Number(contentLength ?? 0);
-  const shouldForceContentLengthCalc = isObject(options.forceStreamSizeCalc) ? options.forceStreamSizeCalc.request : options.forceStreamSizeCalc;
+  const shouldForceContentLengthCalc = isObject(options.forceCalculateStreamSize) ? options.forceCalculateStreamSize.request : options.forceCalculateStreamSize;
   if (!contentLength && shouldForceContentLengthCalc) {
     totalBytes = await calculateTotalBytesFromBody(requestInstance.clone().body, totalBytes);
   }
   let transferredBytes = 0;
   await executeHooks(
     options.onRequestStream({
+      baseConfig,
+      config,
       event: createProgressEvent({ chunk: new Uint8Array(), totalBytes, transferredBytes }),
       options,
       request,
@@ -380,6 +409,8 @@ var toStreamableRequest = async (context) => {
         totalBytes = Math.max(totalBytes, transferredBytes);
         await executeHooks(
           options.onRequestStream?.({
+            baseConfig,
+            config,
             event: createProgressEvent({ chunk, totalBytes, transferredBytes }),
             options,
             request,
@@ -393,19 +424,21 @@ var toStreamableRequest = async (context) => {
   });
 };
 var toStreamableResponse = async (context) => {
-  const { options, request, response } = context;
+  const { baseConfig, config, options, request, response } = context;
   if (!options.onResponseStream || !response.body) {
     return response;
   }
   const contentLength = response.headers.get("content-length");
   let totalBytes = Number(contentLength ?? 0);
-  const shouldForceContentLengthCalc = isObject(options.forceStreamSizeCalc) ? options.forceStreamSizeCalc.response : options.forceStreamSizeCalc;
+  const shouldForceContentLengthCalc = isObject(options.forceCalculateStreamSize) ? options.forceCalculateStreamSize.response : options.forceCalculateStreamSize;
   if (!contentLength && shouldForceContentLengthCalc) {
     totalBytes = await calculateTotalBytesFromBody(response.clone().body, totalBytes);
   }
   let transferredBytes = 0;
   await executeHooks(
     options.onResponseStream({
+      baseConfig,
+      config,
       event: createProgressEvent({ chunk: new Uint8Array(), totalBytes, transferredBytes }),
       options,
       request,
@@ -421,6 +454,8 @@ var toStreamableResponse = async (context) => {
         totalBytes = Math.max(totalBytes, transferredBytes);
         await executeHooks(
           options.onResponseStream?.({
+            baseConfig,
+            config,
             event: createProgressEvent({ chunk, totalBytes, transferredBytes }),
             options,
             request,
@@ -436,16 +471,16 @@ var toStreamableResponse = async (context) => {
 };
 
 // src/dedupe.ts
+var generateDedupeKey = (options, request) => {
+  const shouldHaveDedupeKey = options.dedupeStrategy === "cancel" || options.dedupeStrategy === "defer";
+  if (!shouldHaveDedupeKey) {
+    return null;
+  }
+  return `${options.fullURL}-${JSON.stringify({ options, request })}`;
+};
 var createDedupeStrategy = async (context) => {
-  const { $RequestInfoCache, newFetchController, options, request } = context;
-  const generateDedupeKey = () => {
-    const shouldHaveDedupeKey = options.dedupeStrategy === "cancel" || options.dedupeStrategy === "defer";
-    if (!shouldHaveDedupeKey) {
-      return null;
-    }
-    return `${options.fullURL}-${JSON.stringify({ options, request })}`;
-  };
-  const dedupeKey = options.dedupeKey ?? generateDedupeKey();
+  const { $RequestInfoCache, baseConfig, config, newFetchController, options, request } = context;
+  const dedupeKey = options.dedupeKey ?? generateDedupeKey(options, request);
   const $RequestInfoCacheOrNull = dedupeKey !== null ? $RequestInfoCache : null;
   if (dedupeKey !== null) {
     await waitUntil(0.1);
@@ -466,24 +501,33 @@ var createDedupeStrategy = async (context) => {
       options.fullURL,
       isReadableStream(request.body) && !request.duplex ? { ...request, duplex: "half" } : request
     );
-    void toStreamableRequest({
+    await toStreamableRequest({
+      baseConfig,
+      config,
       options,
       request,
       requestInstance: requestInstance.clone()
     });
-    const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : (
-      // eslint-disable-next-line unicorn/no-nested-ternary -- Allow
-      isReadableStream(request.body) ? fetchApi(requestInstance.clone()) : fetchApi(options.fullURL, request)
-    );
+    const getFetchApiPromise = () => {
+      if (isReadableStream(request.body)) {
+        return fetchApi(requestInstance.clone());
+      }
+      return fetchApi(options.fullURL, request);
+    };
+    const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : getFetchApiPromise();
     $RequestInfoCacheOrNull?.set(dedupeKey, { controller: newFetchController, responsePromise });
     const streamableResponse = toStreamableResponse({
+      baseConfig,
+      config,
       options,
       request,
       response: await responsePromise
     });
     return streamableResponse;
   };
-  const removeDedupeKeyFromCache = () => $RequestInfoCacheOrNull?.delete(dedupeKey);
+  const removeDedupeKeyFromCache = () => {
+    $RequestInfoCacheOrNull?.delete(dedupeKey);
+  };
   return {
     handleRequestCancelStrategy,
     handleRequestDeferStrategy,
@@ -495,61 +539,34 @@ var createDedupeStrategy = async (context) => {
 var definePlugin = (plugin) => {
   return plugin;
 };
-var createMergedHook = (hooks, mergedHooksExecutionMode) => {
-  if (hooks.length === 0) return;
-  const mergedHook = async (ctx) => {
-    if (mergedHooksExecutionMode === "sequential") {
-      for (const hook of hooks) {
-        await hook?.(ctx);
-      }
-      return;
-    }
-    if (mergedHooksExecutionMode === "parallel") {
-      const hookArray = [...hooks];
-      await Promise.all(hookArray.map((uniqueHook) => uniqueHook?.(ctx)));
-    }
-  };
-  return mergedHook;
-};
-var hooksEnum = {
-  onError: /* @__PURE__ */ new Set(),
-  onRequest: /* @__PURE__ */ new Set(),
-  onRequestError: /* @__PURE__ */ new Set(),
-  onRequestStream: /* @__PURE__ */ new Set(),
-  onResponse: /* @__PURE__ */ new Set(),
-  onResponseError: /* @__PURE__ */ new Set(),
-  onResponseStream: /* @__PURE__ */ new Set(),
-  onRetry: /* @__PURE__ */ new Set(),
-  onSuccess: /* @__PURE__ */ new Set()
-};
-var getPluginArray = (plugins) => {
+var resolvePluginArray = (plugins, basePlugins) => {
   if (!plugins) {
     return [];
   }
+  if (isFunction(plugins)) {
+    return plugins({ basePlugins: basePlugins ?? [] });
+  }
   return plugins;
 };
 var initializePlugins = async (context) => {
   const { baseConfig, config, initURL, options, request } = context;
-  const hookRegistries = structuredClone(hooksEnum);
+  const clonedHookRegistries = structuredClone(hookRegistries);
   const addMainHooks = () => {
-    for (const key of Object.keys(hooksEnum)) {
+    for (const key of Object.keys(clonedHookRegistries)) {
       const mainHook = options[key];
-      hookRegistries[key].add(mainHook);
+      clonedHookRegistries[key].add(mainHook);
     }
   };
   const addPluginHooks = (pluginHooks) => {
-    for (const key of Object.keys(hooksEnum)) {
+    for (const key of Object.keys(clonedHookRegistries)) {
       const pluginHook = pluginHooks[key];
-      hookRegistries[key].add(pluginHook);
+      clonedHookRegistries[key].add(pluginHook);
     }
   };
   if (options.mergedHooksExecutionOrder === "mainHooksBeforePlugins") {
     addMainHooks();
   }
-  const resolvedPlugins = [
-    ...getPluginArray(options.plugins),
-    ...getPluginArray(options.extend?.plugins)
-  ];
+  const resolvedPlugins = resolvePluginArray(options.plugins, baseConfig.plugins);
   let resolvedUrl = initURL;
   let resolvedOptions = options;
   let resolvedRequestOptions = request;
@@ -582,10 +599,10 @@ var initializePlugins = async (context) => {
     addMainHooks();
   }
   const resolvedHooks = {};
-  for (const [key, hookRegistry] of Object.entries(hookRegistries)) {
+  for (const [key, hookRegistry] of Object.entries(clonedHookRegistries)) {
     const flattenedHookArray = [...hookRegistry].flat().filter(Boolean);
-    const mergedHook = createMergedHook(flattenedHookArray, options.mergedHooksExecutionMode);
-    resolvedHooks[key] = mergedHook;
+    const composedHook = composeTwoHooks(flattenedHookArray, options.mergedHooksExecutionMode);
+    resolvedHooks[key] = composedHook;
   }
   return {
     resolvedHooks,
@@ -738,10 +755,6 @@ var mergeUrlWithParamsAndQuery = (url, params, query) => {
   return mergeUrlWithQuery(urlWithMergedParams, query);
 };
 
-// src/utils/polyfills.ts
-var createCombinedSignal = (...signals) => AbortSignal.any(signals.filter(Boolean));
-var createTimeoutSignal = (milliseconds) => AbortSignal.timeout(milliseconds);
-
 // src/validation.ts
 var standardSchemaParser = async (schema, inputData) => {
   const result = await schema["~standard"].validate(inputData);
@@ -750,11 +763,6 @@ var standardSchemaParser = async (schema, inputData) => {
   }
   return result.value;
 };
-var createExtensibleSchemasAndValidators = (options) => {
-  const schemas = options.schemas && { ...options.schemas, ...options.extend?.schemas };
-  const validators = options.validators && { ...options.validators, ...options.extend?.validators };
-  return { schemas, validators };
-};
 var handleValidation = async (responseData, schema, validator) => {
   const validResponseData = validator ? validator(responseData) : responseData;
   const schemaValidResponseData = schema ? await standardSchemaParser(schema, validResponseData) : validResponseData;
@@ -762,37 +770,27 @@ var handleValidation = async (responseData, schema, validator) => {
 };
 
 // src/createFetchClient.ts
-var createFetchClient = (baseConfig = {}) => {
+var createFetchClient = (initBaseConfig = {}) => {
   const $RequestInfoCache = /* @__PURE__ */ new Map();
   const callApi2 = async (...parameters) => {
-    const [initURL, config = {}] = parameters;
-    const [fetchOptions, extraOptions] = splitConfig(config);
-    const resolvedBaseConfig = isFunction(baseConfig) ? baseConfig({
-      initURL: initURL.toString(),
-      options: extraOptions,
-      request: fetchOptions
-    }) : baseConfig;
+    const [initURL, initConfig = {}] = parameters;
+    const [fetchOptions, extraOptions] = splitConfig(initConfig);
+    const resolvedBaseConfig = isFunction(initBaseConfig) ? initBaseConfig({ initURL: initURL.toString(), options: extraOptions, request: fetchOptions }) : initBaseConfig;
     const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(resolvedBaseConfig);
-    const initCombinedHooks = {};
-    for (const key of Object.keys(hooksEnum)) {
-      const combinedHook = combineHooks(
-        baseExtraOptions[key],
-        extraOptions[key]
-      );
-      initCombinedHooks[key] = combinedHook;
-    }
     const mergedExtraOptions = {
       ...defaultExtraOptions,
       ...baseExtraOptions,
-      ...!baseExtraOptions.mergeMainOptionsManuallyFromBase && extraOptions
+      ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "options" && extraOptions
     };
     const mergedRequestOptions = {
       ...defaultRequestOptions,
       ...baseFetchOptions,
-      ...fetchOptions
+      ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "request" && fetchOptions
     };
+    const baseConfig = resolvedBaseConfig;
+    const config = initConfig;
     const { resolvedHooks, resolvedOptions, resolvedRequestOptions, url } = await initializePlugins({
-      baseConfig: resolvedBaseConfig,
+      baseConfig,
       config,
       initURL,
       options: mergedExtraOptions,
@@ -823,18 +821,26 @@ var createFetchClient = (baseConfig = {}) => {
       }),
       signal: combinedSignal
     };
-    const { handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({ $RequestInfoCache, newFetchController, options, request });
+    const { handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({
+      $RequestInfoCache,
+      baseConfig,
+      config,
+      newFetchController,
+      options,
+      request
+    });
     await handleRequestCancelStrategy();
     try {
-      await executeHooks(options.onRequest?.({ options, request }));
+      await executeHooks(options.onRequest?.({ baseConfig, config, options, request }));
       request.headers = mergeAndResolveHeaders({
         auth: options.auth,
         body: request.body,
         headers: request.headers
       });
       const response = await handleRequestDeferStrategy();
-      const { schemas, validators } = createExtensibleSchemasAndValidators(options);
       const shouldCloneResponse = options.dedupeStrategy === "defer" || options.cloneResponse;
+      const schemas = isFunction(options.schemas) ? options.schemas({ baseSchemas: baseExtraOptions.schemas ?? {} }) : options.schemas;
+      const validators = isFunction(options.validators) ? options.validators({ baseValidators: baseExtraOptions.validators ?? {} }) : options.validators;
       if (!response.ok) {
         const errorData = await resolveResponseData(
           shouldCloneResponse ? response.clone() : response,
@@ -859,6 +865,8 @@ var createFetchClient = (baseConfig = {}) => {
       );
       const validSuccessData = await handleValidation(successData, schemas?.data, validators?.data);
       const successContext = {
+        baseConfig,
+        config,
         data: validSuccessData,
         options,
         request,
@@ -881,6 +889,8 @@ var createFetchClient = (baseConfig = {}) => {
         resultMode: options.resultMode
       });
       const errorContext = {
+        baseConfig,
+        config,
         error: apiDetails.error,
         options,
         request,
@@ -924,9 +934,9 @@ var createFetchClient = (baseConfig = {}) => {
         return await handleRetryOrGetResult({ message });
       }
       await executeHooks(
-        // == At this point only the request errors exist, so the request error interceptor is called
+        // == At this point only the request errors exist, so the request error hook is called
         options.onRequestError?.(errorContext),
-        // == Also call the onError interceptor
+        // == Also call the onError hook
         options.onError?.(errorContext)
       );
       return await handleRetryOrGetResult();