@funkit/connect 10.1.0-next.0 → 10.1.0

package/dist/clients/chunk-Y2KXVS36.js

@@ -1,230 +0,0 @@
-"use client";
-import {
-  Box
-} from "./chunk-PEVDOGEA.js";
-import {
-  logger
-} from "./chunk-AHYOV7AV.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
-};

package/dist/clients/polymarket/usePolymarketAccountBalances.d.ts

@@ -1,66 +0,0 @@
-import { type QueryClient } from '@tanstack/react-query';
-import type { Address } from 'viem';
-/**
- * Shared query key for a Polymarket account's USD balance, keyed by address.
- * Keying by address (not by the opaque getter fn) is what lets the "Deposit to"
- * dropdown and the in-modal transfer step dedupe into a single cache entry — so
- * navigating between them reuses the already-loaded balance instead of
- * refetching from scratch (no loading flash on entry).
- */
-export declare const polymarketAccountBalanceQueryKey: (address: Address | undefined) => readonly ["polymarket", "accountBalanceUsd", `0x${string}` | null];
-/**
- * Optimistically moves a transfer's amount between the two accounts' displayed
- * balances — call right after the integrator accepts the transfer. `amountUsd`
- * is the exact string the user entered (validated numeric, ≤6 decimals), the
- * same string handed to `transfer` — the math runs in 6-decimal fixed point,
- * never through a float round-trip.
- *
- * This is the standard TanStack optimistic-update sequence: cancel in-flight
- * fetches, write the new values with `setQueryData` so every reader (deposit
- * picker, transfer step) updates immediately, and let the server win again
- * later. "Later" is a settlement window rather than the next poll because the
- * integrator's backend is eventually consistent — it keeps reporting the
- * pre-transfer balances for a few seconds after accepting the transfer, so
- * polls inside the window keep the displayed value instead of flashing back.
- */
-export declare function applyOptimisticTransferBalances(queryClient: QueryClient, transfer: {
-    fromAddress: Address;
-    toAddress: Address;
-    /** Exact entered amount (validated numeric string, ≤6 decimals). */
-    amountUsd: string;
-}): void;
-/** The fields a balance reader needs from a Polymarket account. */
-export interface PolymarketBalanceAccount {
-    address: Address;
-    /** Integrator-owned live balance fetcher (USD). */
-    getBalanceUsd: () => Promise<number>;
-}
-export interface PolymarketAccountBalance {
-    /** Latest polled balance, or `undefined` until the first fetch resolves. */
-    balanceUsd: number | undefined;
-}
-export interface UsePolymarketAccountBalancesOptions {
-    /**
-     * How often (ms) to poll each account's balance. Defaults to
-     * {@link DEFAULT_BALANCE_REFETCH_MS}. A short interval reconciles the
-     * displayed balance with the server soon after a transfer settles.
-     */
-    refetchIntervalMs?: number;
-}
-/**
- * Live USD balances for the Polymarket Predictions and Perps accounts, backed
- * by a single TanStack Query cache keyed by account address. Both the "Deposit
- * to" dropdown and the in-modal transfer step read through this hook, so they
- * share one store: whichever screen loads first populates the balance, and the
- * other reads it instantly on navigation. After a transfer,
- * {@link applyOptimisticTransferBalances} shifts the cached values immediately
- * and the short poll reconciles them with the server once the settlement
- * window closes.
- */
-export declare function usePolymarketAccountBalances(accounts: {
-    predictions: PolymarketBalanceAccount | undefined;
-    perps: PolymarketBalanceAccount | undefined;
-}, options?: UsePolymarketAccountBalancesOptions): {
-    predictions: PolymarketAccountBalance;
-    perps: PolymarketAccountBalance;
-};

package/dist/hooks/useIsTokenWhitelisted.d.ts

@@ -1,30 +0,0 @@
-import { type FlagKey } from '@funkit/utils';
-export declare const MATCH_ALL = "*";
-export type MatchAll = typeof MATCH_ALL;
-export interface TokenWhitelist {
-    [chainId: string | MatchAll]: string[] | [MatchAll] | MatchAll;
-}
-/**
- * Helper to check if a token is whitelisted for a given flag
- * Expects a flag value to be a JSON string of the following format (see {@link TokenWhitelist}):
- * ```json
- * {
- *   "137": ["0xaf88d065e77c8cC2239327C5EDb3A432268e5831"],
- *   "8453": ["0xaf88d065e77c8cC2239327C5EDb3A432268e5831"]
- * }
- * ```
- * Does also support wildcard entries, for example:
- * ```json
- * {
- *   "137": ["*"],
- *   "8453": "*",
- * }
- * ```
- * or even:
- * ```json
- * {
- *   "*": "*"
- * }
- * ```
- */
-export declare const useIsTokenWhitelisted: <T extends FlagKey>(flagKey: T) => (chainId: string, tokenAddress: string) => boolean;

package/dist/modals/CheckoutModal/buildRelayChains.d.ts

@@ -1,12 +0,0 @@
-import type { Chain } from 'viem';
-/**
- * Returns the chain list for the relay client, applying per-chain RPC overrides
- * (keyed by chain id) onto each chain's `rpcUrls.default.http`.
- *
- * The relay-sdk derives the RPC it polls for transaction receipts from each
- * chain's `rpcUrls.default`, so this points that receipt-wait at a reachable
- * endpoint for chains whose default RPC isn't (e.g. an early-access chain like
- * Robinhood). Only chains listed in `rpcOverrides` are changed; everything else
- * is returned unchanged. See {@link FunkitConfig.relayRpcOverrides}.
- */
-export declare function buildRelayChains(chains: readonly Chain[], rpcOverrides?: Record<number, string>): Chain[];

package/dist/providers/FunkitFlagsProvider.d.ts

@@ -1,26 +0,0 @@
-import React, { type ReactNode } from 'react';
-import type { FlagKey } from '@funkit/utils';
-import { flagConfig as offlineConfig } from '../utils/flags/config';
-import type { InferFlagType } from '../utils/flags/types';
-export type FlagValue<K extends FlagKey> = InferFlagType<(typeof offlineConfig)[K]>;
-export type FlagValues = {
-    [K in FlagKey]?: FlagValue<K>;
-};
-export type GetFlagFunction = <K extends FlagKey>(flagKey: K, fallback?: FlagValue<K>) => FlagValue<K>;
-export interface FunkitFlagsContextValue {
-    /** Error fetching flag config from server */
-    error: Error | null;
-    /** Loaded flags - each flag may be undefined if configuration from server was missing or invalid */
-    flags: FlagValues;
-    /** Synchronously reads a single flag (derived for current user) - returns fallback while loading */
-    getFlag: GetFlagFunction;
-    /** Whether flags are currently loading */
-    isLoading: boolean;
-}
-export declare const FunkitFlagsContext: React.Context<FunkitFlagsContextValue>;
-export declare function FunkitFlagsProvider({ children }: {
-    children: ReactNode;
-}): React.JSX.Element;
-export declare function useFlags(): FunkitFlagsContextValue;
-export type FlagMiddleware<K extends FlagKey> = (flagValue: FlagValue<K>) => FlagValue<K>;
-export declare function useFlag<K extends FlagKey>(flagKey: K, fallback?: FlagValue<K>, middleware?: FlagMiddleware<K>): FlagValue<K>;