@zayne-labs/callapi 1.6.14 → 1.6.15

package/dist/cjs/index.cjs

@@ -1 +1,773 @@
-"use strict";var e,r=Object.defineProperty,t=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,s=Object.prototype.hasOwnProperty,n={};((e,t)=>{for(var o in t)r(e,o,{get:t[o],enumerable:!0})})(n,{HTTPError:()=>a,callApi:()=>L,createFetchClient:()=>U,definePlugin:()=>x}),module.exports=(e=n,((e,n,a,i)=>{if(n&&"object"==typeof n||"function"==typeof n)for(let l of o(n))s.call(e,l)||l===a||r(e,l,{get:()=>n[l],enumerable:!(i=t(n,l))||i.enumerable});return e})(r({},"__esModule",{value:!0}),e));var a=class extends Error{errorData;isHTTPError=!0;name="HTTPError";response;constructor(e,r){const{defaultErrorMessage:t,errorData:o,response:s}=e;super(o?.message??t,r),this.errorData=o,this.response=s,Error.captureStackTrace(this,this.constructor)}},i=e=>e instanceof a||d(e)&&"HTTPError"===e.name&&!0===e.isHTTPError,l=e=>Array.isArray(e),u=e=>"object"==typeof e&&null!==e,c=e=>"[object Object]"===Object.prototype.toString.call(e),d=e=>{if(!c(e))return!1;const r=e?.constructor;if(void 0===r)return!0;const t=r.prototype;return!!c(t)&&(!!Object.hasOwn(t,"isPrototypeOf")&&Object.getPrototypeOf(e)===Object.prototype)},p=e=>"function"==typeof e,y=e=>"string"==typeof e,f=e=>p(e)?e():e,h=e=>{if(void 0!==e){if(y(e)||null===e)return{Authorization:`Bearer ${e}`};switch(e.type){case"Basic":{const r=f(e.username),t=f(e.password);if(void 0===r||void 0===t)return;return{Authorization:`Basic ${globalThis.btoa(`${r}:${t}`)}`}}case"Custom":{const r=f(e.value);if(void 0===r)return;return{Authorization:`${f(e.prefix)} ${r}`}}default:{const r=f(e.bearer),t=f(e.token);return"token"in e&&void 0!==t?{Authorization:`Token ${t}`}:void 0!==r&&{Authorization:`Bearer ${r}`}}}}},m=["extend","dedupeKey"],g=["body","integrity","method","headers","signal","cache","redirect","window","credentials","keepalive","referrer","priority","mode","referrerPolicy"],w={408:"Request Timeout",409:"Conflict",425:"Too Early",429:"Too Many Requests",500:"Internal Server Error",502:"Bad Gateway",503:"Service Unavailable",504:"Gateway Timeout"},b=["GET","POST"],E=Object.keys(w).map(Number),R=(e,r)=>{const t={},o=new Set(r);for(const[r,s]of Object.entries(e))o.has(r)||(t[r]=s);return t},S=(e,r)=>{const t={},o=new Set(r);for(const[r,s]of Object.entries(e))o.has(r)&&(t[r]=s);return t},O=e=>!e||d(e)?e:Object.fromEntries(e),v=e=>{const{auth:r,baseHeaders:t,body:o,headers:s}=e;if(!Boolean(t||s||o||r))return;const n={...h(r),...O(t),...O(s)};return y(a=o)&&a.includes("=")?(n["Content-Type"]="application/x-www-form-urlencoded",n):((d(o)||y(o)&&o.startsWith("{"))&&(n["Content-Type"]="application/json",n.Accept="application/json"),n);var a},q=(...e)=>Promise.all(e),T=e=>{if(0===e)return;const{promise:r,resolve:t}=(()=>{let e,r;return{promise:new Promise(((t,o)=>{r=t,e=o})),reject:e,resolve:r}})();return setTimeout(t,e),r},D=async e=>{const{$RequestInfoCache:r,newFetchController:t,options:o,request:s}=e,n=o.dedupeKey??("cancel"===o.dedupeStrategy||"defer"===o.dedupeStrategy?`${o.fullURL}-${JSON.stringify({options:o,request:s})}`:null),a=null!==n?r:null;null!==n&&await T(.1);const i=a?.get(n);return{handleRequestCancelStrategy:()=>{if(!(i&&"cancel"===o.dedupeStrategy))return;const e=o.dedupeKey?`Duplicate request detected - Aborting previous request with key '${o.dedupeKey}' as a new request was initiated`:`Duplicate request detected - Aborting previous request to '${o.fullURL}' as a new request with identical options was initiated`,r=new DOMException(e,"AbortError");return i.controller.abort(r),Promise.resolve()},handleRequestDeferStrategy:()=>{const e=(e=>{if(e)return e;if("undefined"!=typeof globalThis&&p(globalThis.fetch))return globalThis.fetch;throw new Error("No fetch implementation found")})(o.customFetchImpl),r=i&&"defer"===o.dedupeStrategy?i.responsePromise:e(o.fullURL,s);return a?.set(n,{controller:t,responsePromise:r}),r},removeDedupeKeyFromCache:()=>a?.delete(n)}},x=e=>e,j=(e,r)=>async t=>{if("sequential"!==r){if("parallel"===r){const r=[...e];await Promise.all(r.map((e=>e?.(t))))}}else for(const r of e)await(r?.(t))},M={onError:new Set,onRequest:new Set,onRequestError:new Set,onResponse:new Set,onResponseError:new Set,onRetry:new Set,onSuccess:new Set},P=(e,r)=>e?p(e)?e(r):e:[],$=async(e,r,t)=>{const o=((e,r)=>({arrayBuffer:()=>e.arrayBuffer(),blob:()=>e.blob(),formData:()=>e.formData(),json:async()=>{if(r){const t=await e.text();return r(t)}return e.json()},stream:()=>e.body,text:()=>e.text()}))(e,t);if(!Object.hasOwn(o,r))throw new Error(`Invalid response type: ${r}`);return await o[r]()},k=(e,r)=>{const t=e["~retryCount"]??0;return{getDelay:()=>"exponential"===e.retryStrategy?((e,r)=>{const t=r.retryMaxDelay??1e4,o=(r.retryDelay??1e3)*2**e;return Math.min(o,t)})(t,e):(e=>e.retryDelay??1e3)(e),shouldAttemptRetry:async()=>{const o=await(e.retryCondition?.(r))??!0,s=(e.retryAttempts??0)>t&&o;if("HTTPError"!==r.error.name)return s;const n=!!r.request.method&&e.retryMethods?.includes(r.request.method);return!!r.response?.status&&e.retryStatusCodes?.includes(r.response.status)&&n&&s}}},A=(e,r)=>{if(!r)return e;const t=(o=r)?new URLSearchParams(o).toString():(console.error("toQueryString:","No query params provided!"),null);var o;return 0===t?.length?e:e.endsWith("?")?`${e}${t}`:e.includes("?")?`${e}&${t}`:`${e}?${t}`},C=(e,r,t)=>{if(!e)return;const o=((e,r)=>{if(!r)return e;let t=e;if(l(r)){const e=t.split("/").filter((e=>e.startsWith(":")));for(const[o,s]of e.entries()){const e=r[o];t=t.replace(s,e)}return t}for(const[e,o]of Object.entries(r))t=t.replace(`:${e}`,String(o));return t})(e,r);return A(o,t)},H=async(e,r,t)=>{const o=t?t(e):e,s=r?await(async(e,r)=>{const t=await e["~standard"].validate(r);if(t.issues)throw new Error(JSON.stringify(t.issues,null,2),{cause:t.issues});return t.value})(r,o):o;return s},U=e=>{const[r,t]=(e=>[S(e,g),R(e,[...g,...m])])(e??{}),o=new Map,s=async(...e)=>{const[n,c={}]=e,[f,h]=(e=>[S(e,g),R(e,g)])(c),m={};for(const e of Object.keys(M)){const r=(w=t[e],O=h[e],l(w)?[w,O].flat():O??w);m[e]=r}var w,O;const x={baseURL:"",bodySerializer:JSON.stringify,dedupeStrategy:"cancel",defaultErrorMessage:"Failed to fetch data from server!",mergedHooksExecutionMode:"parallel",mergedHooksExecutionOrder:"mainHooksAfterPlugins",responseType:"json",resultMode:"all",retryAttempts:0,retryDelay:1e3,retryMaxDelay:1e4,retryMethods:b,retryStatusCodes:E,retryStrategy:"linear",...t,...h,...m},A=f.body??r.body,U={...r,...f,body:d(A)?x.bodySerializer(A):A,headers:v({auth:x.auth,baseHeaders:r.headers,body:A,headers:f.headers}),signal:f.signal??r.signal},{resolvedHooks:L,resolvedOptions:W,resolvedRequestOptions:B,url:z}=await(async e=>{const{initURL:r,options:t,request:o}=e,s=structuredClone(M),n=()=>{for(const e of Object.keys(M)){const r=t[e];s[e].add(r)}},a=e=>{for(const r of Object.keys(M)){const t=e[r];s[r].add(t)}};"mainHooksBeforePlugins"===t.mergedHooksExecutionOrder&&n();const i=[...P(t.plugins,e),...P(t.extend?.plugins,e)];let l=r,u=t,c=o;const p=async e=>{if(!e)return;const s=await e({initURL:r,options:t,request:o});d(s)&&(y(s.initURL)&&(l=s.initURL),d(s.request)&&(c=s.request),d(s.options)&&(u=s.options))};for(const e of i)await p(e.init),e.hooks&&a(e.hooks);t.mergedHooksExecutionOrder&&"mainHooksAfterPlugins"!==t.mergedHooksExecutionOrder||n();const f={};for(const[e,r]of Object.entries(s)){const o=[...r].flat(),s=j(o,t.mergedHooksExecutionMode);f[e]=s}return{resolvedHooks:f,resolvedOptions:u,resolvedRequestOptions:c,url:l?.toString()}})({initURL:n,options:x,request:U}),F=`${W.baseURL}${C(z,W.params,W.query)}`,N={...W,...L,fullURL:F,initURL:n.toString()},K=new AbortController,I=null!=N.timeout?(G=N.timeout,AbortSignal.timeout(G)):null;var G;const J=((...e)=>AbortSignal.any(e.filter(Boolean)))(B.signal,I,K.signal),_={...B,signal:J},{handleRequestCancelStrategy:Q,handleRequestDeferStrategy:V,removeDedupeKeyFromCache:X}=await D({$RequestInfoCache:o,newFetchController:K,options:N,request:_});await Q();try{await q(N.onRequest({options:N,request:_})),_.headers=v({auth:N.auth,baseHeaders:r.headers,body:A,headers:_.headers});const e=await V(),t="defer"===N.dedupeStrategy||N.cloneResponse,{schemas:o,validators:s}=(e=>({schemas:e.schemas&&{...e.schemas,...e.extend?.schemas},validators:e.validators&&{...e.validators,...e.extend?.validators}}))(N);if(!e.ok){const r=await $(t?e.clone():e,N.responseType,N.responseParser),n=await H(r,o?.errorData,s?.errorData);throw new a({defaultErrorMessage:N.defaultErrorMessage,errorData:n,response:e})}const n=await $(t?e.clone():e,N.responseType,N.responseParser),i={data:await H(n,o?.data,s?.data),options:N,request:_,response:N.cloneResponse?e.clone():e};return await q(N.onSuccess(i),N.onResponse({...i,error:null})),await(e=>{const{data:r,response:t,resultMode:o}=e,s={data:r,error:null,response:t};return o?{all:s,allWithException:s,allWithoutResponse:R(s,["response"]),onlyError:s.error,onlyResponse:s.response,onlyResponseWithException:s.response,onlySuccess:s.data,onlySuccessWithException:s.data}[o]:s})({data:i.data,response:i.response,resultMode:N.resultMode})}catch(e){const{apiDetails:r,getErrorResult:t}=(e=>{const{cloneResponse:r,defaultErrorMessage:t,error:o,message:s,resultMode:n}=e;let a={data:null,error:{errorData:o,message:s??o.message,name:o.name},response:null};if(i(o)){const{errorData:e,message:s=t,name:n,response:i}=o;a={data:null,error:{errorData:e,message:s,name:n},response:r?i.clone():i}}const l={all:a,allWithException:a,allWithoutResponse:R(a,["response"]),onlyError:a.error,onlyResponse:a.response,onlyResponseWithException:a.response,onlySuccess:a.data,onlySuccessWithException:a.data};return{apiDetails:a,getErrorResult:e=>{const r=l[n??"all"];return u(e)?{...r,...e}:r}}})({cloneResponse:N.cloneResponse,defaultErrorMessage:N.defaultErrorMessage,error:e,resultMode:N.resultMode}),o={error:r.error,options:N,request:_,response:r.response},{getDelay:a,shouldAttemptRetry:l}=k(N,o);if(!J.aborted&&await l()){await q(N.onRetry(o));const e=a();await T(e);const r={...c,"~retryCount":(N["~retryCount"]??0)+1};return await s(n,r)}const d=p(N.throwOnError)?N.throwOnError(o):N.throwOnError,y=()=>{if(d)throw r.error};if(i(e))return await q(N.onResponseError(o),N.onError(o),N.onResponse({...o,data:null})),y(),t();if(e instanceof DOMException&&"AbortError"===e.name){const{message:r,name:o}=e;return console.error(`${o}:`,r),y(),t()}if(e instanceof DOMException&&"TimeoutError"===e.name){const r=`Request timed out after ${N.timeout}ms`;return console.error(`${e.name}:`,r),y(),t({message:r})}return await q(N.onRequestError(o),N.onError(o)),y(),t()}finally{X()}};return s.create=U,s},L=U();//# sourceMappingURL=index.cjs.map
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HTTPError: () => HTTPError,
+  callApi: () => callApi,
+  createFetchClient: () => createFetchClient,
+  defineParameters: () => defineParameters,
+  definePlugin: () => definePlugin
+});
+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 = (customInfo) => {
+    const errorResult = resultModeMap[resultMode ?? "all"];
+    return isObject(customInfo) ? { ...errorResult, ...customInfo } : errorResult;
+  };
+  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/type-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 isFunction = (value) => typeof value === "function";
+var isQueryString = (value) => isString(value) && value.includes("=");
+var isString = (value) => typeof value === "string";
+
+// src/auth.ts
+var getValue = (value) => {
+  return isFunction(value) ? value() : value;
+};
+var getAuthHeader = (auth) => {
+  if (auth === void 0) return;
+  if (isString(auth) || auth === null) {
+    return { Authorization: `Bearer ${auth}` };
+  }
+  switch (auth.type) {
+    case "Basic": {
+      const username = getValue(auth.username);
+      const password = getValue(auth.password);
+      if (username === void 0 || password === void 0) return;
+      return {
+        Authorization: `Basic ${globalThis.btoa(`${username}:${password}`)}`
+      };
+    }
+    case "Custom": {
+      const value = getValue(auth.value);
+      if (value === void 0) return;
+      const prefix = getValue(auth.prefix);
+      return {
+        Authorization: `${prefix} ${value}`
+      };
+    }
+    default: {
+      const bearer = getValue(auth.bearer);
+      const token = getValue(auth.token);
+      if ("token" in auth && token !== void 0) {
+        return { Authorization: `Token ${token}` };
+      }
+      return bearer !== void 0 && { Authorization: `Bearer ${bearer}` };
+    }
+  }
+};
+
+// src/utils/type-helpers.ts
+var defineEnum = (value) => value;
+
+// src/types/common.ts
+var optionsEnumToExtendFromBase = defineEnum(["plugins", "validators", "schemas"]);
+var optionsEnumToOmitFromBase = defineEnum(["extend", "dedupeKey"]);
+
+// src/utils/constants.ts
+var fetchSpecificKeys = defineEnum([
+  "body",
+  "integrity",
+  "method",
+  "headers",
+  "signal",
+  "cache",
+  "redirect",
+  "window",
+  "credentials",
+  "keepalive",
+  "referrer",
+  "priority",
+  "mode",
+  "referrerPolicy"
+]);
+var retryStatusCodesLookup = defineEnum({
+  408: "Request Timeout",
+  409: "Conflict",
+  425: "Too Early",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+});
+var defaultRetryMethods = ["GET", "POST"];
+var defaultRetryStatusCodes = Object.keys(retryStatusCodesLookup).map(Number);
+
+// src/utils/common.ts
+var omitKeys = (initialObject, keysToOmit) => {
+  const updatedObject = {};
+  const keysToOmitSet = new Set(keysToOmit);
+  for (const [key, value] of Object.entries(initialObject)) {
+    if (!keysToOmitSet.has(key)) {
+      updatedObject[key] = value;
+    }
+  }
+  return updatedObject;
+};
+var pickKeys = (initialObject, keysToPick) => {
+  const updatedObject = {};
+  const keysToPickSet = new Set(keysToPick);
+  for (const [key, value] of Object.entries(initialObject)) {
+    if (keysToPickSet.has(key)) {
+      updatedObject[key] = value;
+    }
+  }
+  return updatedObject;
+};
+var splitBaseConfig = (baseConfig) => [
+  pickKeys(baseConfig, fetchSpecificKeys),
+  omitKeys(baseConfig, [
+    ...fetchSpecificKeys,
+    ...optionsEnumToOmitFromBase
+  ])
+];
+var splitConfig = (config) => [
+  pickKeys(config, fetchSpecificKeys),
+  omitKeys(config, fetchSpecificKeys)
+];
+var objectifyHeaders = (headers) => {
+  if (!headers || isPlainObject(headers)) {
+    return headers;
+  }
+  return Object.fromEntries(headers);
+};
+var toQueryString = (params) => {
+  if (!params) {
+    console.error("toQueryString:", "No query params provided!");
+    return null;
+  }
+  return new URLSearchParams(params).toString();
+};
+var mergeAndResolveHeaders = (options) => {
+  const { auth, baseHeaders, body, headers } = options;
+  const shouldResolveHeaders = Boolean(baseHeaders || headers || body || auth);
+  if (!shouldResolveHeaders) return;
+  const headersObject = {
+    ...getAuthHeader(auth),
+    ...objectifyHeaders(baseHeaders),
+    ...objectifyHeaders(headers)
+  };
+  if (isQueryString(body)) {
+    headersObject["Content-Type"] = "application/x-www-form-urlencoded";
+    return headersObject;
+  }
+  if (isPlainObject(body) || isString(body) && body.startsWith("{")) {
+    headersObject["Content-Type"] = "application/json";
+    headersObject.Accept = "application/json";
+  }
+  return headersObject;
+};
+var combineHooks = (baseInterceptor, interceptor) => {
+  if (isArray(baseInterceptor)) {
+    return [baseInterceptor, interceptor].flat();
+  }
+  return interceptor ?? baseInterceptor;
+};
+var getFetchImpl = (customFetchImpl) => {
+  if (customFetchImpl) {
+    return customFetchImpl;
+  }
+  if (typeof globalThis !== "undefined" && isFunction(globalThis.fetch)) {
+    return globalThis.fetch;
+  }
+  throw new Error("No fetch implementation found");
+};
+var executeHooks = (...interceptors) => Promise.all(interceptors);
+var PromiseWithResolvers = () => {
+  let reject;
+  let resolve;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, reject, resolve };
+};
+var waitUntil = (delay) => {
+  if (delay === 0) return;
+  const { promise, resolve } = PromiseWithResolvers();
+  setTimeout(resolve, delay);
+  return promise;
+};
+
+// src/dedupe.ts
+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 $RequestInfoCacheOrNull = dedupeKey !== null ? $RequestInfoCache : null;
+  if (dedupeKey !== null) {
+    await waitUntil(0.1);
+  }
+  const prevRequestInfo = $RequestInfoCacheOrNull?.get(dedupeKey);
+  const handleRequestCancelStrategy = () => {
+    const shouldCancelRequest = prevRequestInfo && options.dedupeStrategy === "cancel";
+    if (!shouldCancelRequest) return;
+    const message = options.dedupeKey ? `Duplicate request detected - Aborting previous request with key '${options.dedupeKey}' as a new request was initiated` : `Duplicate request detected - Aborting previous request to '${options.fullURL}' as a new request with identical options was initiated`;
+    const reason = new DOMException(message, "AbortError");
+    prevRequestInfo.controller.abort(reason);
+    return Promise.resolve();
+  };
+  const handleRequestDeferStrategy = () => {
+    const fetchApi = getFetchImpl(options.customFetchImpl);
+    const shouldUsePromiseFromCache = prevRequestInfo && options.dedupeStrategy === "defer";
+    const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : fetchApi(options.fullURL, request);
+    $RequestInfoCacheOrNull?.set(dedupeKey, { controller: newFetchController, responsePromise });
+    return responsePromise;
+  };
+  const removeDedupeKeyFromCache = () => $RequestInfoCacheOrNull?.delete(dedupeKey);
+  return {
+    handleRequestCancelStrategy,
+    handleRequestDeferStrategy,
+    removeDedupeKeyFromCache
+  };
+};
+
+// src/plugins.ts
+var definePlugin = (plugin) => {
+  return plugin;
+};
+var createMergedHook = (hooks, mergedHooksExecutionMode) => {
+  return 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)));
+    }
+  };
+};
+var hooksEnum = {
+  onError: /* @__PURE__ */ new Set(),
+  onRequest: /* @__PURE__ */ new Set(),
+  onRequestError: /* @__PURE__ */ new Set(),
+  onResponse: /* @__PURE__ */ new Set(),
+  onResponseError: /* @__PURE__ */ new Set(),
+  onRetry: /* @__PURE__ */ new Set(),
+  onSuccess: /* @__PURE__ */ new Set()
+};
+var getPluginArray = (plugins, context) => {
+  if (!plugins) {
+    return [];
+  }
+  return isFunction(plugins) ? plugins(context) : plugins;
+};
+var initializePlugins = async (context) => {
+  const { initURL, options, request } = context;
+  const hookRegistries = structuredClone(hooksEnum);
+  const addMainHooks = () => {
+    for (const key of Object.keys(hooksEnum)) {
+      const mainHook = options[key];
+      hookRegistries[key].add(mainHook);
+    }
+  };
+  const addPluginHooks = (pluginHooks) => {
+    for (const key of Object.keys(hooksEnum)) {
+      const pluginHook = pluginHooks[key];
+      hookRegistries[key].add(pluginHook);
+    }
+  };
+  if (options.mergedHooksExecutionOrder === "mainHooksBeforePlugins") {
+    addMainHooks();
+  }
+  const resolvedPlugins = [
+    ...getPluginArray(options.plugins, context),
+    ...getPluginArray(options.extend?.plugins, context)
+  ];
+  let resolvedUrl = initURL;
+  let resolvedOptions = options;
+  let resolvedRequestOptions = request;
+  const executePluginInit = async (pluginInit) => {
+    if (!pluginInit) return;
+    const initResult = await pluginInit({ initURL, options, request });
+    if (!isPlainObject(initResult)) return;
+    if (isString(initResult.initURL)) {
+      resolvedUrl = initResult.initURL;
+    }
+    if (isPlainObject(initResult.request)) {
+      resolvedRequestOptions = initResult.request;
+    }
+    if (isPlainObject(initResult.options)) {
+      resolvedOptions = initResult.options;
+    }
+  };
+  for (const plugin of resolvedPlugins) {
+    await executePluginInit(plugin.init);
+    if (!plugin.hooks) continue;
+    addPluginHooks(plugin.hooks);
+  }
+  if (!options.mergedHooksExecutionOrder || options.mergedHooksExecutionOrder === "mainHooksAfterPlugins") {
+    addMainHooks();
+  }
+  const resolvedHooks = {};
+  for (const [key, hookRegistry] of Object.entries(hookRegistries)) {
+    const flattenedHookArray = [...hookRegistry].flat();
+    const mergedHook = createMergedHook(flattenedHookArray, options.mergedHooksExecutionMode);
+    resolvedHooks[key] = mergedHook;
+  }
+  return {
+    resolvedHooks,
+    resolvedOptions,
+    resolvedRequestOptions,
+    url: resolvedUrl?.toString()
+  };
+};
+
+// src/response.ts
+var getResponseType = (response, parser) => ({
+  arrayBuffer: () => response.arrayBuffer(),
+  blob: () => response.blob(),
+  formData: () => response.formData(),
+  json: async () => {
+    if (parser) {
+      const text = await response.text();
+      return parser(text);
+    }
+    return response.json();
+  },
+  stream: () => response.body,
+  text: () => response.text()
+});
+var resolveResponseData = async (response, responseType, parser) => {
+  const RESPONSE_TYPE_LOOKUP = getResponseType(response, parser);
+  if (!Object.hasOwn(RESPONSE_TYPE_LOOKUP, responseType)) {
+    throw new Error(`Invalid response type: ${responseType}`);
+  }
+  const responseData = await RESPONSE_TYPE_LOOKUP[responseType]();
+  return responseData;
+};
+var resolveSuccessResult = (info) => {
+  const { data, response, resultMode } = info;
+  const apiDetails = { data, error: null, response };
+  if (!resultMode) {
+    return apiDetails;
+  }
+  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
+  };
+  return resultModeMap[resultMode];
+};
+
+// src/retry.ts
+var getLinearDelay = (options) => options.retryDelay ?? 1e3;
+var getExponentialDelay = (currentAttemptCount, options) => {
+  const maxDelay = options.retryMaxDelay ?? 1e4;
+  const exponentialDelay = (options.retryDelay ?? 1e3) * 2 ** currentAttemptCount;
+  return Math.min(exponentialDelay, maxDelay);
+};
+var createRetryStrategy = (options, ctx) => {
+  const currentRetryCount = options["~retryCount"] ?? 0;
+  const getDelay = () => {
+    if (options.retryStrategy === "exponential") {
+      return getExponentialDelay(currentRetryCount, options);
+    }
+    return getLinearDelay(options);
+  };
+  const shouldAttemptRetry = async () => {
+    const customRetryCondition = await options.retryCondition?.(ctx) ?? true;
+    const maxRetryAttempts = options.retryAttempts ?? 0;
+    const baseRetryCondition = maxRetryAttempts > currentRetryCount && customRetryCondition;
+    if (ctx.error.name !== "HTTPError") {
+      return baseRetryCondition;
+    }
+    const includesMethod = (
+      // eslint-disable-next-line no-implicit-coercion -- Boolean doesn't narrow
+      !!ctx.request.method && options.retryMethods?.includes(ctx.request.method)
+    );
+    const includesCodes = (
+      // eslint-disable-next-line no-implicit-coercion -- Boolean doesn't narrow
+      !!ctx.response?.status && options.retryStatusCodes?.includes(ctx.response.status)
+    );
+    return includesCodes && includesMethod && baseRetryCondition;
+  };
+  return {
+    getDelay,
+    shouldAttemptRetry
+  };
+};
+
+// src/url.ts
+var slash = "/";
+var column = ":";
+var mergeUrlWithParams = (url, params) => {
+  if (!params) {
+    return url;
+  }
+  let newUrl = url;
+  if (isArray(params)) {
+    const matchedParamArray = newUrl.split(slash).filter((param) => param.startsWith(column));
+    for (const [index, matchedParam] of matchedParamArray.entries()) {
+      const realParam = params[index];
+      newUrl = newUrl.replace(matchedParam, realParam);
+    }
+    return newUrl;
+  }
+  for (const [key, value] of Object.entries(params)) {
+    newUrl = newUrl.replace(`${column}${key}`, String(value));
+  }
+  return newUrl;
+};
+var questionMark = "?";
+var ampersand = "&";
+var mergeUrlWithQuery = (url, query) => {
+  if (!query) {
+    return url;
+  }
+  const queryString = toQueryString(query);
+  if (queryString?.length === 0) {
+    return url;
+  }
+  if (url.endsWith(questionMark)) {
+    return `${url}${queryString}`;
+  }
+  if (url.includes(questionMark)) {
+    return `${url}${ampersand}${queryString}`;
+  }
+  return `${url}${questionMark}${queryString}`;
+};
+var mergeUrlWithParamsAndQuery = (url, params, query) => {
+  if (!url) return;
+  const urlWithMergedParams = mergeUrlWithParams(url, params);
+  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);
+  if (result.issues) {
+    throw new Error(JSON.stringify(result.issues, null, 2), { cause: result.issues });
+  }
+  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;
+  return schemaValidResponseData;
+};
+
+// src/createFetchClient.ts
+var createFetchClient = (baseConfig) => {
+  const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(baseConfig ?? {});
+  const $RequestInfoCache = /* @__PURE__ */ new Map();
+  const callApi2 = async (...parameters) => {
+    const [initURL, config = {}] = parameters;
+    const [fetchOptions, extraOptions] = splitConfig(config);
+    const initCombinedHooks = {};
+    for (const key of Object.keys(hooksEnum)) {
+      const combinedHook = combineHooks(
+        baseExtraOptions[key],
+        extraOptions[key]
+      );
+      initCombinedHooks[key] = combinedHook;
+    }
+    const defaultExtraOptions = {
+      baseURL: "",
+      bodySerializer: JSON.stringify,
+      dedupeStrategy: "cancel",
+      defaultErrorMessage: "Failed to fetch data from server!",
+      mergedHooksExecutionMode: "parallel",
+      mergedHooksExecutionOrder: "mainHooksAfterPlugins",
+      responseType: "json",
+      resultMode: "all",
+      retryAttempts: 0,
+      retryDelay: 1e3,
+      retryMaxDelay: 1e4,
+      retryMethods: defaultRetryMethods,
+      retryStatusCodes: defaultRetryStatusCodes,
+      retryStrategy: "linear",
+      ...baseExtraOptions,
+      ...extraOptions,
+      ...initCombinedHooks
+    };
+    const body = fetchOptions.body ?? baseFetchOptions.body;
+    const defaultRequestOptions = {
+      ...baseFetchOptions,
+      ...fetchOptions,
+      body: isPlainObject(body) ? defaultExtraOptions.bodySerializer(body) : body,
+      headers: mergeAndResolveHeaders({
+        auth: defaultExtraOptions.auth,
+        baseHeaders: baseFetchOptions.headers,
+        body,
+        headers: fetchOptions.headers
+      }),
+      signal: fetchOptions.signal ?? baseFetchOptions.signal
+    };
+    const { resolvedHooks, resolvedOptions, resolvedRequestOptions, url } = await initializePlugins({
+      initURL,
+      options: defaultExtraOptions,
+      request: defaultRequestOptions
+    });
+    const fullURL = `${resolvedOptions.baseURL}${mergeUrlWithParamsAndQuery(url, resolvedOptions.params, resolvedOptions.query)}`;
+    const options = {
+      ...resolvedOptions,
+      ...resolvedHooks,
+      fullURL,
+      initURL: initURL.toString()
+    };
+    const newFetchController = new AbortController();
+    const timeoutSignal = options.timeout != null ? createTimeoutSignal(options.timeout) : null;
+    const combinedSignal = createCombinedSignal(
+      resolvedRequestOptions.signal,
+      timeoutSignal,
+      newFetchController.signal
+    );
+    const request = {
+      ...resolvedRequestOptions,
+      signal: combinedSignal
+    };
+    const { handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({ $RequestInfoCache, newFetchController, options, request });
+    await handleRequestCancelStrategy();
+    try {
+      await executeHooks(options.onRequest({ options, request }));
+      request.headers = mergeAndResolveHeaders({
+        auth: options.auth,
+        baseHeaders: baseFetchOptions.headers,
+        body,
+        headers: request.headers
+      });
+      const response = await handleRequestDeferStrategy();
+      const shouldCloneResponse = options.dedupeStrategy === "defer" || options.cloneResponse;
+      const { schemas, validators } = createExtensibleSchemasAndValidators(options);
+      if (!response.ok) {
+        const errorData = await resolveResponseData(
+          shouldCloneResponse ? response.clone() : response,
+          options.responseType,
+          options.responseParser
+        );
+        const validErrorData = await handleValidation(
+          errorData,
+          schemas?.errorData,
+          validators?.errorData
+        );
+        throw new HTTPError({
+          defaultErrorMessage: options.defaultErrorMessage,
+          errorData: validErrorData,
+          response
+        });
+      }
+      const successData = await resolveResponseData(
+        shouldCloneResponse ? response.clone() : response,
+        options.responseType,
+        options.responseParser
+      );
+      const validSuccessData = await handleValidation(successData, schemas?.data, validators?.data);
+      const successContext = {
+        data: validSuccessData,
+        options,
+        request,
+        response: options.cloneResponse ? response.clone() : response
+      };
+      await executeHooks(
+        options.onSuccess(successContext),
+        options.onResponse({ ...successContext, error: null })
+      );
+      return await resolveSuccessResult({
+        data: successContext.data,
+        response: successContext.response,
+        resultMode: options.resultMode
+      });
+    } catch (error) {
+      const { apiDetails, getErrorResult } = resolveErrorResult({
+        cloneResponse: options.cloneResponse,
+        defaultErrorMessage: options.defaultErrorMessage,
+        error,
+        resultMode: options.resultMode
+      });
+      const errorContext = {
+        error: apiDetails.error,
+        options,
+        request,
+        response: apiDetails.response
+      };
+      const { getDelay, shouldAttemptRetry } = createRetryStrategy(options, errorContext);
+      const shouldRetry = !combinedSignal.aborted && await shouldAttemptRetry();
+      if (shouldRetry) {
+        await executeHooks(options.onRetry(errorContext));
+        const delay = getDelay();
+        await waitUntil(delay);
+        const updatedOptions = {
+          ...config,
+          "~retryCount": (options["~retryCount"] ?? 0) + 1
+        };
+        return await callApi2(initURL, updatedOptions);
+      }
+      const shouldThrowOnError = isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError;
+      const handleThrowOnError = () => {
+        if (!shouldThrowOnError) return;
+        throw apiDetails.error;
+      };
+      if (isHTTPErrorInstance(error)) {
+        await executeHooks(
+          options.onResponseError(errorContext),
+          options.onError(errorContext),
+          options.onResponse({ ...errorContext, data: null })
+        );
+        handleThrowOnError();
+        return getErrorResult();
+      }
+      if (error instanceof DOMException && error.name === "AbortError") {
+        const { message, name } = error;
+        console.error(`${name}:`, message);
+        handleThrowOnError();
+        return getErrorResult();
+      }
+      if (error instanceof DOMException && error.name === "TimeoutError") {
+        const message = `Request timed out after ${options.timeout}ms`;
+        console.error(`${error.name}:`, message);
+        handleThrowOnError();
+        return getErrorResult({ message });
+      }
+      await executeHooks(
+        // == At this point only the request errors exist, so the request error interceptor is called
+        options.onRequestError(errorContext),
+        // == Also call the onError interceptor
+        options.onError(errorContext)
+      );
+      handleThrowOnError();
+      return getErrorResult();
+    } finally {
+      removeDedupeKeyFromCache();
+    }
+  };
+  callApi2.create = createFetchClient;
+  return callApi2;
+};
+var callApi = createFetchClient();
+
+// src/defineParameters.ts
+var defineParameters = (...parameters) => {
+  return parameters;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HTTPError,
+  callApi,
+  createFetchClient,
+  defineParameters,
+  definePlugin
+});
+//# sourceMappingURL=index.cjs.map