@funkit/connect 9.19.1 → 9.21.0

package/dist/clients/chunk-KSSSSWR6.js

@@ -0,0 +1,54 @@
+"use client";
+import {
+  Box
+} from "./chunk-52NKHZS2.js";
+
+// src/components/Text/Text.tsx
+import React from "react";
+var Text = React.forwardRef(
+  ({
+    as = "div",
+    children,
+    className,
+    color = "primaryText",
+    display,
+    font = "body",
+    id,
+    size = "16",
+    style,
+    tabIndex,
+    title,
+    textAlign = "inherit",
+    textTransform = "none",
+    weight = "regular",
+    testId
+  }, ref) => {
+    return /* @__PURE__ */ React.createElement(
+      Box,
+      {
+        as,
+        className,
+        color: color === "inherit" ? void 0 : color,
+        display,
+        fontFamily: font,
+        fontSize: size,
+        fontWeight: weight,
+        id,
+        title,
+        ref,
+        style,
+        tabIndex,
+        textAlign,
+        textTransform,
+        testId,
+        background: { selection: "textSelection" }
+      },
+      children
+    );
+  }
+);
+Text.displayName = "Text";
+
+export {
+  Text
+};

package/dist/clients/{polymarket.js → chunk-MOUTRRN3.js}

@@ -3,7 +3,7 @@ import {
   logger
 } from "./chunk-UUHGOBKZ.js";
 
-// src/clients/polymarket.tsx
+// src/clients/polymarket/polymarket.tsx
 import {
   POLYMARKET_API_KEY,
   initializeCheckoutTokenTransferAddress
@@ -366,7 +366,7 @@ function checkFeatureGate(name) {
   }
 }
 
-// src/clients/polymarket.tsx
+// src/clients/polymarket/polymarket.tsx
 var PMCT_WITHDRAW_ACTION_TYPE = "PMCT_WITHDRAW";
 var POLYGON_USDCE = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
 var PUSD_TOKEN = {
@@ -682,7 +682,15 @@ function createPerpsGenerateActionParams(config) {
     ];
   };
 }
+
 export {
-  createPerpsGenerateActionParams,
-  createPolymarketWithdrawalConfig
+  POLYGON_USDCE,
+  PUSD_TOKEN,
+  createPolymarketWithdrawalConfig,
+  COLLATERAL_ONRAMP_ADDRESS,
+  COLLATERAL_ONRAMP_ABI,
+  VAULT_DEPOSITOR_POLYGON,
+  VAULT_DEPOSITOR_ABI,
+  AMOUNT_PLACEHOLDER,
+  createPerpsGenerateActionParams
 };

package/dist/clients/chunk-MRBN4XCA.js

@@ -0,0 +1,96 @@
+"use client";
+import {
+  logger
+} from "./chunk-UUHGOBKZ.js";
+
+// src/clients/polymarket/usePolymarketAccountBalances.ts
+import {
+  skipToken,
+  useQuery,
+  useQueryClient
+} from "@tanstack/react-query";
+import * as dnum from "dnum";
+var DEFAULT_BALANCE_REFETCH_MS = 1e3;
+var polymarketAccountBalanceQueryKey = (address) => ["polymarket", "accountBalanceUsd", address ?? null];
+var polymarketBalanceSettleUntilQueryKey = (address) => ["polymarket", "accountBalanceSettleUntil", address];
+var PUSD_DECIMALS = 6;
+var SETTLEMENT_WINDOW_MS = 3e4;
+function applyOptimisticTransferBalances(queryClient, transfer) {
+  const { fromAddress, toAddress, amountUsd } = transfer;
+  const amount = dnum.from(amountUsd, PUSD_DECIMALS);
+  shiftBalance(queryClient, fromAddress, dnum.multiply(amount, -1));
+  shiftBalance(queryClient, toAddress, amount);
+}
+function shiftBalance(queryClient, address, deltaUsd) {
+  const balanceKey = polymarketAccountBalanceQueryKey(address);
+  const displayedUsd = queryClient.getQueryData(balanceKey);
+  if (displayedUsd === void 0) {
+    return;
+  }
+  void queryClient.cancelQueries({ queryKey: balanceKey });
+  queryClient.setQueryData(
+    polymarketBalanceSettleUntilQueryKey(address),
+    Date.now() + SETTLEMENT_WINDOW_MS
+  );
+  queryClient.setQueryData(
+    balanceKey,
+    Math.max(0, dnum.toNumber(dnum.add(displayedUsd, deltaUsd, PUSD_DECIMALS)))
+  );
+}
+async function fetchAccountBalance(queryClient, getBalanceUsd, queryKey) {
+  const [, , address] = queryKey;
+  if (address === null) {
+    throw new Error("polymarket balance query ran without an address");
+  }
+  try {
+    const serverUsd = await getBalanceUsd();
+    const settleUntil = queryClient.getQueryData(
+      polymarketBalanceSettleUntilQueryKey(address)
+    );
+    const displayedUsd = queryClient.getQueryData(
+      polymarketAccountBalanceQueryKey(address)
+    );
+    if (settleUntil !== void 0 && Date.now() < settleUntil && displayedUsd !== void 0) {
+      return displayedUsd;
+    }
+    return serverUsd;
+  } catch (error) {
+    logger.warn("polymarket:accountBalance:fetchFailed", {
+      address,
+      error: String(error)
+    });
+    throw error;
+  }
+}
+function useAccountBalance(account, refetchIntervalMs) {
+  const queryClient = useQueryClient();
+  const getBalanceUsd = account?.getBalanceUsd;
+  const address = account?.address;
+  const query = useQuery({
+    queryKey: polymarketAccountBalanceQueryKey(address),
+    // `skipToken` disables the query when the account isn't configured (the
+    // perps-transfer config is optional). It is *not* a fallback for a missing
+    // balance — the getter is the single source of truth.
+    queryFn: getBalanceUsd && address ? ({ queryKey }) => fetchAccountBalance(queryClient, getBalanceUsd, queryKey) : skipToken,
+    refetchInterval: refetchIntervalMs,
+    // The poll interval is the freshness contract: a reader mounting within it
+    // (e.g. navigating between the deposit picker and the transfer step) reads
+    // the cached balance as-is instead of kicking off an extra mount fetch —
+    // that's what makes the navigation flash-free *and* fetch-free.
+    staleTime: refetchIntervalMs
+  });
+  return { balanceUsd: query.data };
+}
+function usePolymarketAccountBalances(accounts, options) {
+  const refetchIntervalMs = options?.refetchIntervalMs ?? DEFAULT_BALANCE_REFETCH_MS;
+  return {
+    predictions: useAccountBalance(accounts.predictions, refetchIntervalMs),
+    perps: useAccountBalance(accounts.perps, refetchIntervalMs)
+  };
+}
+
+export {
+  polymarketAccountBalanceQueryKey,
+  applyOptimisticTransferBalances,
+  usePolymarketAccountBalances
+};

package/dist/clients/chunk-NCCAYPLO.js

@@ -0,0 +1,230 @@
+"use client";
+import {
+  Box
+} from "./chunk-52NKHZS2.js";
+import {
+  logger
+} from "./chunk-UUHGOBKZ.js";
+
+// src/components/AsyncImage/useAsyncImage.ts
+import { useEffect, useReducer } from "react";
+var cachedUrls = /* @__PURE__ */ new Map();
+var cachedRequestPromises = /* @__PURE__ */ new Map();
+async function loadAsyncImage(asyncImage) {
+  const cachedRequestPromise = cachedRequestPromises.get(asyncImage);
+  if (cachedRequestPromise) {
+    return cachedRequestPromise;
+  }
+  const load = async () => asyncImage().then(async (url) => {
+    cachedUrls.set(asyncImage, url);
+    return url;
+  });
+  const requestPromise = load().catch(async () => {
+    return load().catch(() => {
+      cachedRequestPromises.delete(asyncImage);
+      return void 0;
+    });
+  });
+  cachedRequestPromises.set(asyncImage, requestPromise);
+  return requestPromise;
+}
+function useForceUpdate() {
+  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  return forceUpdate;
+}
+function useAsyncImage(url) {
+  const cachedUrl = typeof url === "function" ? cachedUrls.get(url) : void 0;
+  const forceUpdate = useForceUpdate();
+  useEffect(() => {
+    if (typeof url === "function" && !cachedUrl) {
+      loadAsyncImage(url).then(forceUpdate);
+    }
+  }, [url, cachedUrl, forceUpdate]);
+  return typeof url === "function" ? cachedUrl : url;
+}
+var REMOTE_IMG_CACHE = /* @__PURE__ */ new Set();
+function preloadRemoteImages(...imageUrls) {
+  for (const imageUrl of imageUrls) {
+    try {
+      const { protocol } = new URL(imageUrl);
+      if (protocol !== "https:" && protocol !== "http:") {
+        logger.warn("preloadRemoteImages:invalidUrl", {
+          message: "Invalid protocol",
+          imageUrl
+        });
+        continue;
+      }
+      if (!REMOTE_IMG_CACHE.has(imageUrl)) {
+        REMOTE_IMG_CACHE.add(imageUrl);
+        const preloadImage = new Image();
+        preloadImage.src = imageUrl;
+      }
+    } catch (error) {
+      logger.warn("preloadRemoteImages:error", {
+        message: "Unable to preload image",
+        imageUrl,
+        error
+      });
+    }
+  }
+}
+
+// src/components/AsyncImage/AsyncImage.tsx
+import React, { useMemo, useReducer as useReducer2, useState } from "react";
+
+// src/utils/sanitizeUrl.ts
+var SAFE_URL_PROTOCOLS = /* @__PURE__ */ new Set(["https:", "http:"]);
+function sanitizeUrl(url) {
+  if (!url) {
+    return void 0;
+  }
+  try {
+    const parsed = new URL(url);
+    if (SAFE_URL_PROTOCOLS.has(parsed.protocol)) {
+      return parsed.href;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function sanitizeCssUrl(url) {
+  const safeUrl = sanitizeUrl(url);
+  if (!safeUrl) {
+    return void 0;
+  }
+  return safeUrl.replace(/['()\\]/g, (char) => {
+    return `%${char.charCodeAt(0).toString(16).padStart(2, "0")}`;
+  });
+}
+
+// src/components/AsyncImage/AsyncImage.tsx
+function useTriggeredOnce() {
+  return useReducer2(() => true, false);
+}
+function AsyncImage({
+  alt,
+  background,
+  borderColor,
+  borderRadius,
+  boxShadow,
+  height,
+  useAsImage,
+  src: srcProp,
+  fallbackSrc,
+  fallbackElement,
+  width,
+  testId
+}) {
+  const src = useAsyncImage(srcProp || fallbackSrc);
+  const isRemoteImage = src !== void 0 && /^(https?|data):/.test(src);
+  const [isRemoteImageLoaded, setRemoteImageLoaded] = useTriggeredOnce();
+  const [hasError, setHasError] = useState(
+    srcProp === void 0 && fallbackSrc === void 0
+  );
+  const { asyncStyle, imgProps } = useMemo(() => {
+    const asyncStyle2 = !useAsImage ? getRemoteImageStyles(isRemoteImage, isRemoteImageLoaded, src) : {};
+    if (useAsImage || isRemoteImage) {
+      const imgProps2 = {
+        as: "img",
+        src,
+        "aria-hidden": true,
+        onError: ({
+          currentTarget
+        }) => {
+          currentTarget.onerror = null;
+          if (fallbackSrc !== void 0) {
+            currentTarget.src = fallbackSrc;
+          } else {
+            setHasError(true);
+          }
+        },
+        onLoad: isRemoteImage ? setRemoteImageLoaded : void 0
+      };
+      return { imgProps: imgProps2, asyncStyle: asyncStyle2 };
+    }
+    return {
+      imgProps: {
+        backgroundSize: "cover"
+      },
+      asyncStyle: {
+        ...asyncStyle2,
+        // has to be added as a inline style because vanilla-extract doesn't recognize this as a valid style
+        backgroundPosition: "center"
+      }
+    };
+  }, [
+    fallbackSrc,
+    isRemoteImage,
+    isRemoteImageLoaded,
+    src,
+    useAsImage,
+    setRemoteImageLoaded
+  ]);
+  const mainElement = hasError && fallbackElement || /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      ...imgProps,
+      height: "full",
+      position: "absolute",
+      style: {
+        WebkitTouchCallout: "none",
+        transition: "opacity .15s linear",
+        userSelect: "none",
+        ...asyncStyle
+      },
+      width: "full"
+    }
+  );
+  return /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      "aria-label": alt,
+      borderRadius,
+      boxShadow,
+      height: typeof height === "string" ? height : void 0,
+      overflow: "hidden",
+      position: "relative",
+      role: "img",
+      style: {
+        background,
+        height: typeof height === "number" ? height : void 0,
+        width: typeof width === "number" ? width : void 0
+      },
+      width: typeof width === "string" ? width : void 0,
+      testId
+    },
+    mainElement,
+    borderColor ? /* @__PURE__ */ React.createElement(
+      Box,
+      {
+        ...typeof borderColor === "object" && "custom" in borderColor ? { style: { borderColor: borderColor.custom } } : { borderColor },
+        borderRadius,
+        borderStyle: "solid",
+        borderWidth: "1",
+        height: "full",
+        position: "relative",
+        width: "full"
+      }
+    ) : null
+  );
+}
+var getRemoteImageStyles = (isRemoteImage, isRemoteImageLoaded, src) => {
+  if (isRemoteImage) {
+    return {
+      opacity: isRemoteImageLoaded ? 1 : 0
+    };
+  }
+  const safeSrc = sanitizeCssUrl(src);
+  return {
+    // note the url must have quotation, see https://github.com/evanw/esbuild/issues/1843#issuecomment-1370108070
+    backgroundImage: safeSrc ? `url('${safeSrc}')` : void 0,
+    backgroundRepeat: "no-repeat",
+    opacity: src ? 1 : 0
+  };
+};
+
+export {
+  preloadRemoteImages,
+  AsyncImage
+};