@skip-go/client 1.6.0-alpha.3 → 1.6.0-alpha.5

package/dist/cjs/chunk-2QPPD3BB.cjs

@@ -0,0 +1,210 @@
+'use strict';
+
+// src/utils/timer.ts
+var wait = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+// src/utils/convert.ts
+function toSnake(obj) {
+  return convertKeys(obj, (key) => key.replace(/([A-Z])/g, "_$1").toLowerCase());
+}
+function toCamel(obj) {
+  return convertKeys(obj, (key) => key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()));
+}
+function convertKeys(obj, convertKey) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => convertKeys(item, convertKey));
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.keys(obj).reduce((acc, key) => {
+      acc[convertKey(key)] = convertKeys(obj[key], convertKey);
+      return acc;
+    }, {});
+  } else {
+    return obj;
+  }
+}
+
+// src/utils/generateApi.ts
+var createRequestClient = ({ apiUrl, apiKey, apiHeaders }) => {
+  if (!apiUrl?.endsWith("/")) {
+    apiUrl += "/";
+  }
+  const headers = new Headers({
+    "content-type": "application/json"
+  });
+  if (apiKey) {
+    headers.set("authorization", apiKey);
+  }
+  if (apiHeaders) {
+    new Headers(apiHeaders).forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  const handleResponse = async (response) => {
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType?.includes("application/json");
+    const body = isJson ? await response.json() : await response.text();
+    if (!response.ok) {
+      const message = typeof body === "object" && body?.message ? body.message : response.statusText;
+      const error = new Error(message);
+      if (body?.code) {
+        error.code = body.code;
+      }
+      if (body?.details) {
+        error.details = body.details;
+      }
+      throw error;
+    }
+    return body;
+  };
+  const get = async (path, params, signal) => {
+    if (path?.startsWith("/")) {
+      console.warn("paths that start with / are treated as absolute paths, please remove the leading / if this path is intended to be a relative path");
+    }
+    const url = new URL(path ?? "", apiUrl);
+    if (params && typeof params === "object") {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          if (Array.isArray(value)) {
+            value.forEach((item) => {
+              url.searchParams.append(key, String(item));
+            });
+          } else {
+            url.searchParams.append(key, String(value));
+          }
+        }
+      });
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers,
+      signal
+    });
+    return handleResponse(response);
+  };
+  const post = async (path, data = {}, signal) => {
+    if (path?.startsWith("/")) {
+      console.warn("paths that start with / are treated as absolute paths, please remove the leading / if this path is intended to be a relative path");
+    }
+    const response = await fetch(new URL(path, apiUrl).toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(data),
+      signal
+    });
+    return handleResponse(response);
+  };
+  return { get, post };
+};
+function createRequest({
+  path,
+  method = "get",
+  onSuccess,
+  transformResponse
+}) {
+  let controller = null;
+  const request = async (options) => {
+    const { apiKey, apiUrl, apiHeaders, abortDuplicateRequests, ...requestParams } = options ?? {};
+    let fetchClient = ApiState.client;
+    if (apiKey || apiUrl || apiHeaders || fetchClient === void 0) {
+      fetchClient = createRequestClient({
+        apiUrl: apiUrl || "https://api.skip.build",
+        apiKey,
+        apiHeaders
+      });
+    }
+    ApiState.apiCalled = true;
+    if (abortDuplicateRequests && controller && !controller?.signal?.aborted) {
+      controller?.abort();
+    }
+    controller = new AbortController();
+    try {
+      const response = await fetchClient[method](
+        path,
+        requestParams ? toSnake(requestParams) : void 0,
+        controller.signal
+      );
+      const camelCased = toCamel(response ?? {});
+      const finalResponse = transformResponse ? transformResponse(camelCased) : camelCased;
+      onSuccess?.(finalResponse, requestParams);
+      return finalResponse;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        console.log("Request was cancelled");
+      } else {
+        console.error("Error:", error);
+        throw error;
+      }
+    }
+  };
+  return request;
+}
+function api({
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  methodName,
+  path,
+  onSuccess,
+  method = "get",
+  transformResponse
+}) {
+  return createRequest({
+    path,
+    method,
+    onSuccess,
+    transformResponse
+  });
+}
+function pollingApi({
+  methodName,
+  path,
+  method = "get",
+  onSuccess,
+  onError,
+  isSuccess = () => true,
+  maxRetries = 10,
+  retryInterval = 1e3,
+  backoffMultiplier = 2,
+  throwOnError = false
+}) {
+  const request = async (requestParams) => {
+    let attempt = 0;
+    let lastError;
+    while (attempt < maxRetries) {
+      try {
+        const result = await api({ methodName, path, method })(requestParams);
+        if (result && isSuccess(result)) {
+          onSuccess?.(result, attempt);
+          return result;
+        }
+      } catch (err) {
+        lastError = err;
+        onError?.(err, attempt);
+        if (throwOnError) {
+          throw err;
+        }
+      }
+      const delay = retryInterval * Math.pow(backoffMultiplier, attempt);
+      await wait(delay);
+      attempt++;
+    }
+    throw lastError ?? new Error("pollingApi: max retries exceeded");
+  };
+  return (params) => request(params);
+}
+
+// src/state/apiState.ts
+var ApiState = class {
+  static client;
+  static chainIdsToAffiliates;
+  static cumulativeAffiliateFeeBPS = "0";
+  static initialized = false;
+  static apiCalled = false;
+};
+
+exports.ApiState = ApiState;
+exports.api = api;
+exports.createRequestClient = createRequestClient;
+exports.pollingApi = pollingApi;
+exports.toCamel = toCamel;
+exports.wait = wait;

package/dist/cjs/chunk-2SA3OAIJ.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunk2QPPD3BB_cjs = require('./chunk-2QPPD3BB.cjs');
+
+// src/api/postRoute.ts
+var route = async (request) => {
+  const requestWithAffiliateFeeBps = {
+    ...request,
+    cumulativeAffiliateFeeBps: chunk2QPPD3BB_cjs.ApiState.cumulativeAffiliateFeeBPS
+  };
+  return chunk2QPPD3BB_cjs.api({
+    methodName: "route",
+    method: "post",
+    path: "v2/fungible/route"
+  })(requestWithAffiliateFeeBps);
+};
+
+exports.route = route;