@coin-voyage/paykit 0.0.2 → 0.1.0

package/dist/paykit/src/components/Pages/Onboarding/styles.js

@@ -1,229 +0,0 @@
-import { motion } from 'framer-motion';
-import { keyframes } from 'styled-components';
-import defaultTheme from '../../../lib/config/default-theme.js';
-import styled from '../../../styles/styled/index.js';
-
-const Graphic = styled(motion.div) `
-  position: relative;
-  margin: 16px auto 20px;
-  height: 190px;
-  max-width: 295px;
-  pointer-events: none;
-  user-select: none;
-  @media only screen and (max-width: ${defaultTheme.mobileWidth}px) {
-    height: 200px;
-    max-width: 100%;
-    margin-bottom: 32px;
-  }
-`;
-const LogoGroup = styled(motion.div) `
-  position: absolute;
-  inset: 0;
-  z-index: 2;
-`;
-const graphicIn = keyframes `
-  0%{
-    opacity:0;
-    transform:scale(0.9);
-  }
-  100%{
-    opacity:1;
-    transform:none;
-  }
-`;
-const GraphicBackground = styled(motion.div) `
-  z-index: 1;
-  position: absolute;
-  inset: 0;
-  top: -2px;
-  overflow: hidden;
-  &:before {
-    content: "";
-    position: absolute;
-    inset: 0;
-    background: var(--ck-body-background);
-    background: radial-gradient(
-      closest-side,
-      var(--ck-body-background-transparent, transparent) 18.75%,
-      var(--ck-body-background) 100%
-    );
-    background-size: 100%;
-  }
-  svg {
-    display: block;
-    width: 100%;
-    height: auto;
-  }
-  animation: ${graphicIn} 1000ms 100ms ease both;
-  // @media only screen and (max-width: ${defaultTheme.mobileWidth}px) {
-  //   animation: none;
-  // }
-`;
-const logoIn = keyframes `
-  0%{
-    opacity:0;
-    transform:scale(0) translateY(40%);
-  }
-  100%{
-    opacity:1;
-    transform:none;
-  }
-`;
-const LogoPosition = styled(motion.div) `
-  position: absolute;
-  inset: 0;
-  animation: cubic-bezier(0.455, 0.03, 0.515, 0.955) infinite both;
-  animation-delay: inherit;
-`;
-const LogoInner = styled(motion.div) `
-  position: absolute;
-`;
-const LogoGraphic = styled(motion.div) `
-  position: relative;
-  overflow: hidden;
-  height: 58px;
-  width: 58px;
-  border-radius: 13.84px;
-  box-shadow:
-    0 0 0 1px rgba(0, 0, 0, 0.05),
-    0 2px 20px 0 rgba(0, 0, 0, 0.03);
-
-  svg {
-    display: block;
-    width: 100%;
-    height: 100%;
-  }
-`;
-const float = keyframes `
-  0%,100%{ transform:none; }
-  50%{ transform: translateY(-10%) }
-`;
-const FloatWrapper = styled(motion.div) `
-  position: relative;
-  animation: cubic-bezier(0.455, 0.03, 0.515, 0.955) infinite both;
-  animation-name: ${float};
-  animation-duration: 3600ms;
-`;
-const rotate = keyframes `
-  0%,100%{ transform:rotate(-3deg); }
-  50%{ transform:rotate(3deg); }
-`;
-const RotateWrapper = styled(motion.div) `
-  position: relative;
-  animation: cubic-bezier(0.455, 0.03, 0.515, 0.955) infinite both;
-  animation-name: ${rotate};
-  animation-duration: 3200ms;
-`;
-const Logo = styled(motion.div) `
-  position: absolute;
-  inset: 0;
-
-  animation: ${logoIn} 750ms cubic-bezier(0.19, 1, 0.22, 1) both;
-  &:nth-child(1) {
-    z-index: 2;
-    animation-delay: 0ms;
-  }
-  &:nth-child(2) {
-    z-index: 1;
-    animation-delay: 60ms;
-  }
-  &:nth-child(3) {
-    z-index: 1;
-    animation-delay: 30ms;
-  }
-  &:nth-child(4) {
-    z-index: 1;
-    animation-delay: 90ms;
-  }
-  &:nth-child(5) {
-    z-index: 1;
-    animation-delay: 120ms;
-  }
-
-  &:nth-child(1) {
-    ${RotateWrapper} {
-      animation-delay: 0ms;
-    }
-  }
-  &:nth-child(2) {
-    ${RotateWrapper} {
-      animation-delay: -600ms;
-    }
-  }
-  &:nth-child(3) {
-    ${RotateWrapper} {
-      animation-delay: -1200ms;
-    }
-  }
-  &:nth-child(4) {
-    ${RotateWrapper} {
-      animation-delay: -1800ms;
-    }
-  }
-  &:nth-child(5) {
-    ${RotateWrapper} {
-      animation-delay: -2400ms;
-    }
-  }
-
-  &:nth-child(1) {
-    ${FloatWrapper} {
-      animation-delay: -200ms;
-    }
-  }
-  &:nth-child(2) {
-    ${FloatWrapper} {
-      animation-delay: -600ms;
-    }
-  }
-  &:nth-child(3) {
-    ${FloatWrapper} {
-      animation-delay: -800ms;
-    }
-  }
-  &:nth-child(4) {
-    ${FloatWrapper} {
-      animation-delay: -300ms;
-    }
-  }
-  &:nth-child(5) {
-    ${FloatWrapper} {
-      animation-delay: -3200ms;
-    }
-  }
-
-  // @media only screen and (max-width: ${defaultTheme.mobileWidth}px) {
-  //   animation: none !important;
-  //   ${RotateWrapper},${FloatWrapper} {
-  //     animation: none !important;
-  //   }
-  }
-
-  ${LogoInner} {
-    transform: translate(-50%, -50%);
-  }
-
-  &:nth-child(1) ${LogoPosition} {
-    transform: translate(50%, 50%);
-    ${LogoGraphic} {
-      border-radius: 17.2px;
-      width: 72px;
-      height: 72px;
-    }
-  }
-  &:nth-child(2) ${LogoPosition} {
-    transform: translate(21%, 21.5%);
-  }
-  &:nth-child(3) ${LogoPosition} {
-    transform: translate(78%, 14%);
-  }
-  &:nth-child(4) ${LogoPosition} {
-    transform: translate(22.5%, 76%);
-  }
-  &:nth-child(5) ${LogoPosition} {
-    transform: translate(76%, 80%);
-  }
-`;
-
-export { FloatWrapper, Graphic, GraphicBackground, Logo, LogoGraphic, LogoGroup, LogoInner, LogoPosition, RotateWrapper };
-//# sourceMappingURL=styles.js.map

package/dist/paykit/src/components/Pages/Onboarding/styles.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"styles.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/paykit/src/components/Pages/PayWithToken/index.js

@@ -1,174 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { useState, useEffect } from 'react';
-import { ROUTES } from '../../../types/routes.js';
-import { PageContent, ModalContent, ModalH1 } from '../../ui/Modal/styles.js';
-import { getChainTypeByChainId, ChainType } from '../../../../../shared/src/common/chains.js';
-import '../../../../../shared/src/common/pay.js';
-import '../../../../../shared/src/common/model.js';
-import { motion, AnimatePresence } from 'framer-motion';
-import { css } from 'styled-components';
-import { useChainId, useSwitchChain } from 'wagmi';
-import { useAccount } from '../../../hooks/useAccount.js';
-import styled from '../../../styles/styled/index.js';
-import usePayContext from '../../contexts/pay/index.js';
-import CircleSpinner from '../../spinners/CircleSpinner/index.js';
-import Button from '../../ui/Button/index.js';
-
-var PayState;
-(function (PayState) {
-    PayState["RequestingPayment"] = "Requesting Payment";
-    PayState["SwitchingChain"] = "Switching Chain";
-    PayState["RequestCancelled"] = "Payment Cancelled";
-    PayState["RequestSuccessful"] = "Payment Successful";
-})(PayState || (PayState = {}));
-function PayWithToken() {
-    const { triggerResize, paymentState, setRoute, log } = usePayContext();
-    const { selectedTokenOption, payWithToken } = paymentState;
-    const [payState, setPayState] = useState(PayState.RequestingPayment);
-    const chainType = getChainTypeByChainId(paymentState.selectedTokenOption?.chainId);
-    useAccount({
-        chainType,
-        selectedWallet: paymentState.selectedWallet,
-    });
-    const walletChainId = useChainId();
-    const { switchChainAsync } = useSwitchChain();
-    const trySwitchingChain = async (option, forceSwitch = false) => {
-        if (walletChainId !== option.chainId || forceSwitch) {
-            const resultChain = await (async () => {
-                try {
-                    return await switchChainAsync({
-                        chainId: option.chainId,
-                    });
-                }
-                catch (e) {
-                    console.error("Failed to switch chain", e);
-                    return null;
-                }
-            })();
-            if (resultChain?.id !== option.chainId) {
-                return false;
-            }
-        }
-        return true;
-    };
-    const handleTransfer = async (option) => {
-        // Switch chain if necessary
-        if (chainType === ChainType.EVM) {
-            setPayState(PayState.SwitchingChain);
-            const switchChain = await trySwitchingChain(option);
-            if (!switchChain) {
-                console.error("Switching chain failed");
-                setPayState(PayState.RequestCancelled);
-                return;
-            }
-        }
-        setPayState(PayState.RequestingPayment);
-        try {
-            await payWithToken(option);
-            setPayState(PayState.RequestSuccessful);
-            setTimeout(() => {
-                setRoute(ROUTES.CONFIRMATION);
-            }, 200);
-        }
-        catch (e) {
-            if (e?.name === "ConnectorChainMismatchError") {
-                // Workaround for Rainbow wallet bug -- user is able to switch chain without
-                // the wallet updating the chain ID for wagmi.
-                log("Chain mismatch detected, attempting to switch and retry");
-                const switchSuccessful = await trySwitchingChain(option, true);
-                if (switchSuccessful) {
-                    try {
-                        await payWithToken(option);
-                        return; // Payment successful after switching chain
-                    }
-                    catch (retryError) {
-                        console.error("Failed to pay with token after switching chain", retryError);
-                        throw retryError;
-                    }
-                }
-            }
-            setPayState(PayState.RequestCancelled);
-            console.error("Failed to pay with token", e);
-        }
-    };
-    let transferTimeout; // Prevent double-triggering in React dev strict mode.
-    useEffect(() => {
-        if (!selectedTokenOption) {
-            return;
-        }
-        // Give user time to see the UI before opening
-        transferTimeout = setTimeout(() => {
-            handleTransfer(selectedTokenOption);
-        }, 100);
-        return () => {
-            clearTimeout(transferTimeout);
-        };
-    }, []);
-    useEffect(() => {
-        triggerResize();
-    }, [payState]);
-    return (jsxs(PageContent, { children: [jsx(LoadingContainer, { children: jsx(AnimationContainer, { "$circle": true, children: jsx(AnimatePresence, { children: jsx(CircleSpinner, { logo: jsx("img", { src: selectedTokenOption?.token.image, alt: selectedTokenOption?.token.ticker }, selectedTokenOption?.token.image), loading: true, unavailable: false }, "CircleSpinner") }) }) }), jsxs(ModalContent, { style: { paddingBottom: 0 }, children: [jsx(ModalH1, { children: payState }), payState === PayState.RequestCancelled && (jsx(Button, { onClick: () => selectedTokenOption ? handleTransfer(selectedTokenOption) : null, children: "Retry Payment" }))] })] }));
-}
-const LoadingContainer = styled(motion.div) `
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  margin: 10px auto 16px;
-  height: 120px;
-`;
-const AnimationContainer = styled(motion.div) `
-  user-select: none;
-  position: relative;
-  --spinner-error-opacity: 0;
-  &:before {
-    content: "";
-    position: absolute;
-    inset: 1px;
-    opacity: 0;
-    background: var(--ck-body-color-danger);
-    ${(props) => props.$circle &&
-    css `
-        inset: -5px;
-        border-radius: 50%;
-        background: none;
-        box-shadow: inset 0 0 0 3.5px var(--ck-body-color-danger);
-      `}
-  }
-`;
-styled(motion.div) `
-  z-index: 10;
-  position: absolute;
-  right: 2px;
-  bottom: 2px;
-  padding: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 32px;
-  height: 32px;
-  border-radius: 16px;
-  overflow: hidden;
-
-  color: var(--ck-body-background);
-  transition: color 200ms ease;
-
-  &:before {
-    z-index: 5;
-    content: "";
-    position: absolute;
-    inset: 0;
-    opacity: 0;
-    transition: opacity 200ms ease;
-    background: var(--ck-body-color);
-  }
-
-  svg {
-    display: block;
-    position: relative;
-    width: 100%;
-    height: 100%;
-  }
-`;
-
-export { PayWithToken as default };
-//# sourceMappingURL=index.js.map

package/dist/paykit/src/components/Pages/PayWithToken/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/paykit/src/components/Pages/SelectMethod/index.js

@@ -1,139 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { useConfig as useConfig$1 } from '@bigmi/react';
-import { getAddressContraction } from '../../../../../shared/src/common/account.js';
-import { ChainType } from '../../../../../shared/src/common/chains.js';
-import '../../../../../shared/src/common/pay.js';
-import '../../../../../shared/src/common/model.js';
-import { useWallets } from '@mysten/dapp-kit';
-import { useWallet } from '@solana/wallet-adapter-react';
-import { useConfig } from 'wagmi';
-import { Ethereum, Optimism, Arbitrum, Avalanche, Solana, Sui, Bitcoin } from '../../../assets/chains.js';
-import { MetaMask } from '../../../assets/logos.js';
-import { useAccount } from '../../../hooks/useAccount.js';
-import { ROUTES } from '../../../types/routes.js';
-import usePayContext from '../../contexts/pay/index.js';
-import { SquircleIcon } from '../../ui/Icon/index.js';
-import { PageContent } from '../../ui/Modal/styles.js';
-import OptionsList from '../../ui/OptionsList/index.js';
-import { OrderHeader } from '../../ui/OrderHeader/index.js';
-import PoweredByFooter from '../../ui/PoweredByFooter/index.js';
-import useIsMobile from '../../../../../shared/src/hooks/use-is-mobile.js';
-
-function getEVMOptions() {
-    const wagmiConfig = useConfig();
-    const { setRoute, paymentState } = usePayContext();
-    if (wagmiConfig.connectors.length === 0) {
-        return null;
-    }
-    return {
-        id: "evm",
-        title: "Pay on Ethereum",
-        subtitle: "Mainnet, Optimism, Arbitrum...",
-        iconShape: "circle",
-        icons: [jsx(Ethereum, {}), jsx(Optimism, {}), jsx(Arbitrum, {}), jsx(Avalanche, {})],
-        onClick: () => {
-            paymentState.setConnectorChainType(ChainType.EVM);
-            setRoute(ROUTES.CONNECTORS);
-        },
-    };
-}
-function getSolanaOption() {
-    const { wallets } = useWallet();
-    const { setRoute, paymentState } = usePayContext();
-    if (wallets.length === 0) {
-        return null;
-    }
-    return {
-        id: "solana",
-        title: "Pay on Solana",
-        icons: [jsx(Solana, {})],
-        onClick: () => {
-            paymentState.setConnectorChainType(ChainType.SOL);
-            setRoute(ROUTES.CONNECTORS);
-        },
-    };
-}
-function getSuiOption() {
-    const wallets = useWallets();
-    const { setRoute, paymentState } = usePayContext();
-    if (wallets.length === 0) {
-        return null;
-    }
-    return {
-        id: "sui",
-        title: "Pay on Sui",
-        icons: [jsx(Sui, {})],
-        onClick: () => {
-            paymentState.setConnectorChainType(ChainType.SUI);
-            setRoute(ROUTES.CONNECTORS);
-        },
-    };
-}
-function getBitcoinOption() {
-    const bigmiConfig = useConfig$1();
-    const { setRoute, paymentState } = usePayContext();
-    if (bigmiConfig.connectors.length === 0) {
-        return null;
-    }
-    return {
-        id: "bitcoin",
-        title: "Pay with Bitcoin",
-        icons: [jsx(Bitcoin, {})],
-        onClick: () => {
-            paymentState.setConnectorChainType(ChainType.UTXO);
-            setRoute(ROUTES.CONNECTORS);
-        },
-    };
-}
-function SelectMethod() {
-    const isMobile = useIsMobile();
-    const { setRoute, paymentState } = usePayContext();
-    const { account } = useAccount({
-        selectedWallet: paymentState.selectedWallet,
-        chainType: paymentState.connectorChainType,
-    });
-    //const disconnect = useAccountDisconnect();
-    const { senderEnsName } = paymentState;
-    const displayName = senderEnsName ??
-        (account?.address ? getAddressContraction(account.address) : "wallet");
-    const connectedWalletOption = account?.isConnected
-        ? {
-            id: "connectedWallet",
-            title: `Pay with ${displayName}`,
-            icons: [
-                account?.connector?.icon ? (jsx(SquircleIcon, { icon: account.connector.icon, alt: account.connector.name })) : (jsx(MetaMask, {})),
-            ],
-            onClick: () => {
-                paymentState.setConnectorChainType(account.chainType);
-                setRoute(ROUTES.SELECT_TOKEN);
-            },
-        }
-        : null;
-    // const unconnectedWalletOption = {
-    //   id: "unconnectedWallet",
-    //   title: account?.isConnected ? `Pay with another wallet` : `Pay with wallet`,
-    //   icons: getBestUnconnectedWalletIcons(account?.connector),
-    //   onClick: async () => {
-    //     await disconnect(account);
-    //     setRoute(ROUTES.CONNECTORS);
-    //   },
-    // };
-    // const walletOptions = connectedWalletOption
-    //   ? [connectedWalletOption, unconnectedWalletOption]
-    //   : [unconnectedWalletOption];
-    const evmOption = getEVMOptions();
-    const solanaOption = getSolanaOption();
-    const suiOption = getSuiOption();
-    const bitcoinOption = getBitcoinOption();
-    const options = [
-        ...(connectedWalletOption ? [connectedWalletOption] : []),
-        ...(evmOption ? [evmOption] : []),
-        ...(solanaOption ? [solanaOption] : []),
-        ...(suiOption ? [suiOption] : []),
-        ...(bitcoinOption ? [bitcoinOption] : []),
-    ];
-    return (jsxs(PageContent, { children: [jsx(OrderHeader, {}), jsx(OptionsList, { requiredSkeletons: isMobile ? 4 : 3, options: options }), jsx(PoweredByFooter, {})] }));
-}
-
-export { SelectMethod as default };
-//# sourceMappingURL=index.js.map

package/dist/paykit/src/components/Pages/SelectMethod/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/paykit/src/components/Pages/SelectToken/index.js

@@ -1,56 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { ROUTES } from '../../../types/routes.js';
-import { PageContent, ModalContent, ModalH1 } from '../../ui/Modal/styles.js';
-import { motion } from 'framer-motion';
-import styled from '../../../styles/styled/index.js';
-import usePayContext from '../../contexts/pay/index.js';
-import Button from '../../ui/Button/index.js';
-import OptionsList from '../../ui/OptionsList/index.js';
-import { OrderHeader } from '../../ui/OrderHeader/index.js';
-
-const TokenChainLogo = ({ token }) => {
-    return (jsx(TokenChainContainer, { children: jsx("img", { src: token.image, alt: token.ticker, style: { borderRadius: 9999 } }) }));
-};
-const TokenChainContainer = styled(motion.div) `
-  width: 100%;
-  height: 100%;
-`;
-styled(motion.div) `
-  position: absolute;
-  width: 16px;
-  height: 16px;
-  border-radius: 9999px;
-  overflow: hidden;
-  bottom: 0px;
-  right: 0px;
-`;
-function SelectToken() {
-    const { setRoute, paymentState } = usePayContext();
-    const { setSelectedTokenOption, walletPaymentOptions } = paymentState;
-    return (jsxs(PageContent, { children: [jsx(OrderHeader, { minified: true }), !walletPaymentOptions.isLoading &&
-                walletPaymentOptions.options?.length === 0 && (jsxs(ModalContent, { style: {
-                    display: "flex",
-                    alignItems: "center",
-                    justifyContent: "center",
-                    paddingTop: 16,
-                    paddingBottom: 16,
-                }, children: [jsx(ModalH1, { children: "Insufficient balance." }), jsx(Button, { onClick: () => setRoute(ROUTES.SELECT_METHOD), children: "Select Another Method" })] })), jsx(OptionsList, { requiredSkeletons: 4, isLoading: walletPaymentOptions.isLoading, options: walletPaymentOptions.options?.map((option) => {
-                    const title = option.token.name;
-                    const subtitle = `Balance: ${option.balance?.uiAmountString} ${option.token.ticker}`;
-                    return {
-                        id: option.token.id,
-                        title,
-                        subtitle,
-                        icons: [
-                            jsx(TokenChainLogo, { token: option.token }, option.token.id),
-                        ],
-                        onClick: () => {
-                            setSelectedTokenOption(option);
-                            setRoute(ROUTES.PAY_WITH_TOKEN);
-                        },
-                    };
-                }) ?? [] })] }));
-}
-
-export { SelectToken as default };
-//# sourceMappingURL=index.js.map

package/dist/paykit/src/components/Pages/SelectToken/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/paykit/src/components/Pages/SwitchNetworks/index.js

@@ -1,26 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { useConnect, useDisconnect, useAccount } from 'wagmi';
-import ChainSelectList from '../../ui/ChainSelectList/index.js';
-import { PageContent, ModalContent, ModalBody } from '../../ui/Modal/styles.js';
-import useLocales from '../../../hooks/useLocales.js';
-import { DisconnectIcon } from '../../../assets/icons.js';
-import { useChainIsSupported } from '../../../hooks/useChainIsSupported.js';
-import { isSafeConnector } from '../../../utils/index.js';
-import Button from '../../ui/Button/index.js';
-import { OrDivider } from '../../ui/Modal/index.js';
-
-const SwitchNetworks = () => {
-    const { reset } = useConnect();
-    const { disconnect } = useDisconnect();
-    const { connector, chain } = useAccount();
-    const isChainSupported = useChainIsSupported(chain?.id);
-    const locales = useLocales({});
-    const onDisconnect = () => {
-        disconnect();
-        reset();
-    };
-    return (jsx(PageContent, { style: { width: 278 }, children: jsxs(ModalContent, { style: { padding: 0, marginTop: -10 }, children: [!isChainSupported && (jsxs(ModalBody, { children: [locales.warnings_chainUnsupported, " ", locales.warnings_chainUnsupportedResolve] })), jsx("div", { style: { padding: "6px 8px" }, children: jsx(ChainSelectList, { variant: "secondary" }) }), !isChainSupported && !isSafeConnector(connector?.id) && (jsxs("div", { style: { paddingTop: 12 }, children: [jsx(OrDivider, {}), jsx(Button, { icon: jsx(DisconnectIcon, {}), variant: "secondary", onClick: onDisconnect, children: locales.disconnect })] }))] }) }));
-};
-
-export { SwitchNetworks as default };
-//# sourceMappingURL=index.js.map

package/dist/paykit/src/components/Pages/SwitchNetworks/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/paykit/src/components/callback-handler.d.ts

@@ -1,3 +0,0 @@
-import { PropsWithChildren } from "react";
-import { useConnectCallbackProps } from "../hooks/useConnectCallback";
-export default function CallBackHandler(props: PropsWithChildren<useConnectCallbackProps>): import("react/jsx-runtime").JSX.Element;

package/dist/paykit/src/components/callback-handler.js

@@ -1,16 +0,0 @@
-import { jsx, Fragment } from 'react/jsx-runtime';
-import { useConnectCallback } from '../hooks/useConnectCallback.js';
-import { useInWagmiContext } from '../providers/evm/provider.js';
-
-function CallBackHandler(props) {
-    const inWagmiContext = useInWagmiContext();
-    if (!inWagmiContext) {
-        return jsx(Fragment, { children: props.children });
-    }
-    const { onConnect, onDisconnect } = props;
-    useConnectCallback({ onConnect, onDisconnect });
-    return jsx(Fragment, { children: props.children });
-}
-
-export { CallBackHandler as default };
-//# sourceMappingURL=callback-handler.js.map

package/dist/paykit/src/components/callback-handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"callback-handler.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}

package/dist/paykit/src/components/contexts/app/index.d.ts

@@ -1,8 +0,0 @@
-import React from "react";
-import type { WalletConfiguration } from "../../../types";
-type AppContextValue = {
-    walletConfig?: WalletConfiguration;
-};
-export declare const AppContext: React.Context<AppContextValue | null>;
-export declare function useAppContext(): AppContextValue;
-export {};