@zayne-labs/callapi 1.7.5 → 1.7.8

package/dist/cjs/index.cjs

@@ -1,967 +0,0 @@
-"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,
-  getDefaultOptions: () => getDefaultOptions
-});
-module.exports = __toCommonJS(index_exports);
-
-// 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);
-      }
-      return;
-    }
-    if (mergedHooksExecutionMode === "parallel") {
-      const hookArray = [...hooks];
-      await Promise.all(hookArray.map((uniqueHook) => uniqueHook?.(ctx)));
-    }
-  };
-  return mergedHook;
-};
-var executeHooks = (...hooks) => Promise.all(hooks);
-
-// 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 optionsEnumToOmitFromBase = defineEnum(["dedupeKey"]);
-
-// src/utils/constants.ts
-var fetchSpecificKeys = defineEnum([
-  "body",
-  "integrity",
-  "duplex",
-  "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);
-var 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"
-};
-var defaultRequestOptions = {
-  method: "GET"
-};
-var getDefaultOptions = () => defaultExtraOptions;
-
-// 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 toQueryString = (params) => {
-  if (!params) {
-    console.error("toQueryString:", "No query params provided!");
-    return null;
-  }
-  return new URLSearchParams(params).toString();
-};
-var objectifyHeaders = (headers) => {
-  if (!headers || isPlainObject(headers)) {
-    return headers;
-  }
-  return Object.fromEntries(headers);
-};
-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 (isSerializable(body) || isJsonString(body)) {
-    headersObject["Content-Type"] = "application/json";
-    headersObject.Accept = "application/json";
-  }
-  return headersObject;
-};
-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 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;
-};
-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) => {
-  const { chunk, totalBytes, transferredBytes } = options;
-  return {
-    chunk,
-    progress: Math.round(transferredBytes / totalBytes * 100) || 0,
-    totalBytes,
-    transferredBytes
-  };
-};
-var calculateTotalBytesFromBody = async (requestBody, existingTotalBytes) => {
-  let totalBytes = existingTotalBytes;
-  if (!requestBody) {
-    return totalBytes;
-  }
-  for await (const chunk of requestBody) {
-    totalBytes += chunk.byteLength;
-  }
-  return totalBytes;
-};
-var toStreamableRequest = async (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.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,
-      requestInstance
-    })
-  );
-  const body = requestInstance.body;
-  void new ReadableStream({
-    start: async (controller) => {
-      if (!body) return;
-      for await (const chunk of body) {
-        transferredBytes += chunk.byteLength;
-        totalBytes = Math.max(totalBytes, transferredBytes);
-        await executeHooks(
-          options.onRequestStream?.({
-            baseConfig,
-            config,
-            event: createProgressEvent({ chunk, totalBytes, transferredBytes }),
-            options,
-            request,
-            requestInstance
-          })
-        );
-        controller.enqueue(chunk);
-      }
-      controller.close();
-    }
-  });
-};
-var toStreamableResponse = async (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.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,
-      response
-    })
-  );
-  const body = response.body;
-  const stream = new ReadableStream({
-    start: async (controller) => {
-      if (!body) return;
-      for await (const chunk of body) {
-        transferredBytes += chunk.byteLength;
-        totalBytes = Math.max(totalBytes, transferredBytes);
-        await executeHooks(
-          options.onResponseStream?.({
-            baseConfig,
-            config,
-            event: createProgressEvent({ chunk, totalBytes, transferredBytes }),
-            options,
-            request,
-            response
-          })
-        );
-        controller.enqueue(chunk);
-      }
-      controller.close();
-    }
-  });
-  return new Response(stream, response);
-};
-
-// 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, 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);
-  }
-  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 = async () => {
-    const fetchApi = getFetchImpl(options.customFetchImpl);
-    const shouldUsePromiseFromCache = prevRequestInfo && options.dedupeStrategy === "defer";
-    const requestInstance = new Request(
-      options.fullURL,
-      isReadableStream(request.body) && !request.duplex ? { ...request, duplex: "half" } : request
-    );
-    await toStreamableRequest({
-      baseConfig,
-      config,
-      options,
-      request,
-      requestInstance: requestInstance.clone()
-    });
-    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);
-  };
-  return {
-    handleRequestCancelStrategy,
-    handleRequestDeferStrategy,
-    removeDedupeKeyFromCache
-  };
-};
-
-// src/plugins.ts
-var definePlugin = (plugin) => {
-  return plugin;
-};
-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 clonedHookRegistries = structuredClone(hookRegistries);
-  const addMainHooks = () => {
-    for (const key of Object.keys(clonedHookRegistries)) {
-      const mainHook = options[key];
-      clonedHookRegistries[key].add(mainHook);
-    }
-  };
-  const addPluginHooks = (pluginHooks) => {
-    for (const key of Object.keys(clonedHookRegistries)) {
-      const pluginHook = pluginHooks[key];
-      clonedHookRegistries[key].add(pluginHook);
-    }
-  };
-  if (options.mergedHooksExecutionOrder === "mainHooksBeforePlugins") {
-    addMainHooks();
-  }
-  const resolvedPlugins = resolvePluginArray(options.plugins, baseConfig.plugins);
-  let resolvedUrl = initURL;
-  let resolvedOptions = options;
-  let resolvedRequestOptions = request;
-  const executePluginInit = async (pluginInit) => {
-    if (!pluginInit) return;
-    const initResult = await pluginInit({
-      baseConfig,
-      config,
-      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(clonedHookRegistries)) {
-    const flattenedHookArray = [...hookRegistry].flat().filter(Boolean);
-    const composedHook = composeTwoHooks(flattenedHookArray, options.mergedHooksExecutionMode);
-    resolvedHooks[key] = composedHook;
-  }
-  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 (!responseType) {
-    return RESPONSE_TYPE_LOOKUP.json();
-  }
-  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 = (ctx) => {
-  const { 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;
-  };
-  const executeRetryHook = async (shouldThrowOnError) => {
-    try {
-      return await executeHooks(options.onRetry?.(ctx));
-    } catch (error) {
-      const { apiDetails } = resolveErrorResult({
-        cloneResponse: options.cloneResponse,
-        defaultErrorMessage: options.defaultErrorMessage,
-        error,
-        resultMode: options.resultMode
-      });
-      if (shouldThrowOnError) {
-        throw error;
-      }
-      return apiDetails;
-    }
-  };
-  return {
-    executeRetryHook,
-    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/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 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 = (initBaseConfig = {}) => {
-  const $RequestInfoCache = /* @__PURE__ */ new Map();
-  const callApi2 = async (...parameters) => {
-    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 mergedExtraOptions = {
-      ...defaultExtraOptions,
-      ...baseExtraOptions,
-      ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "options" && extraOptions
-    };
-    const mergedRequestOptions = {
-      ...defaultRequestOptions,
-      ...baseFetchOptions,
-      ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "request" && fetchOptions
-    };
-    const baseConfig = resolvedBaseConfig;
-    const config = initConfig;
-    const { resolvedHooks, resolvedOptions, resolvedRequestOptions, url } = await initializePlugins({
-      baseConfig,
-      config,
-      initURL,
-      options: mergedExtraOptions,
-      request: mergedRequestOptions
-    });
-    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,
-      body: isSerializable(resolvedRequestOptions.body) ? options.bodySerializer(resolvedRequestOptions.body) : resolvedRequestOptions.body,
-      headers: mergeAndResolveHeaders({
-        auth: options.auth,
-        baseHeaders: baseFetchOptions.headers,
-        body: resolvedRequestOptions.body,
-        headers: fetchOptions.headers
-      }),
-      signal: combinedSignal
-    };
-    const { handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({
-      $RequestInfoCache,
-      baseConfig,
-      config,
-      newFetchController,
-      options,
-      request
-    });
-    await handleRequestCancelStrategy();
-    try {
-      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 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,
-          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 = {
-        baseConfig,
-        config,
-        data: validSuccessData,
-        options,
-        request,
-        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 = {
-        baseConfig,
-        config,
-        error: apiDetails.error,
-        options,
-        request,
-        response: apiDetails.response
-      };
-      const shouldThrowOnError = isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError;
-      const handleRetryOrGetResult = async (customInfo) => {
-        const { executeRetryHook, getDelay, shouldAttemptRetry } = createRetryStrategy(errorContext);
-        const shouldRetry = !combinedSignal.aborted && await shouldAttemptRetry();
-        if (shouldRetry) {
-          await executeRetryHook(shouldThrowOnError);
-          const delay = getDelay();
-          await waitUntil(delay);
-          const updatedOptions = {
-            ...config,
-            "~retryCount": (options["~retryCount"] ?? 0) + 1
-          };
-          return callApi2(initURL, updatedOptions);
-        }
-        if (shouldThrowOnError) {
-          throw error;
-        }
-        return customInfo ? getErrorResult(customInfo) : getErrorResult();
-      };
-      if (isHTTPErrorInstance(error)) {
-        await executeHooks(
-          options.onResponseError?.(errorContext),
-          options.onError?.(errorContext),
-          options.onResponse?.({ ...errorContext, data: null })
-        );
-        return await handleRetryOrGetResult();
-      }
-      if (error instanceof DOMException && error.name === "AbortError") {
-        const { message, name } = error;
-        !shouldThrowOnError && console.error(`${name}:`, message);
-        return await handleRetryOrGetResult();
-      }
-      if (error instanceof DOMException && error.name === "TimeoutError") {
-        const message = `Request timed out after ${options.timeout}ms`;
-        !shouldThrowOnError && console.error(`${error.name}:`, message);
-        return await handleRetryOrGetResult({ message });
-      }
-      await executeHooks(
-        // == At this point only the request errors exist, so the request error hook is called
-        options.onRequestError?.(errorContext),
-        // == Also call the onError hook
-        options.onError?.(errorContext)
-      );
-      return await handleRetryOrGetResult();
-    } finally {
-      removeDedupeKeyFromCache();
-    }
-  };
-  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,
-  getDefaultOptions
-});
-//# sourceMappingURL=index.cjs.map