@coin-voyage/paykit 0.0.2 → 0.1.1

package/dist/paykit/src/hooks/useUniversalConnect.js

@@ -1,114 +0,0 @@
-import { useConfig } from '@bigmi/react';
-import { ChainType } from '../../../shared/src/common/chains.js';
-import '../../../shared/src/common/pay.js';
-import '../../../shared/src/common/model.js';
-import { useConnectWallet } from '@mysten/dapp-kit';
-import { useWallet } from '@solana/wallet-adapter-react';
-import { useConfig as useConfig$1, useConnect } from 'wagmi';
-import usePayContext from '../components/contexts/pay/index.js';
-import { useAccount } from './useAccount.js';
-
-const useUniversalConnect = (props) => {
-    const { log, paymentState } = usePayContext();
-    const utxoConfig = useConfig();
-    const evmConfig = useConfig$1();
-    const { select, disconnect, connected } = useWallet();
-    const { mutateAsync: suiConnectAsync } = useConnectWallet();
-    const connectedAccount = useAccount({
-        selectedWallet: paymentState.selectedWallet,
-        chainType: paymentState.connectorChainType,
-    });
-    const { connectAsync } = useConnect({
-        config: evmConfig,
-        mutation: {
-            ...props,
-            onSuccess(data, variables) {
-                const connector = variables.connector ||
-                    variables.connector;
-                props?.onSuccess?.(data, {
-                    chainId: variables?.chainId,
-                    connector,
-                });
-            },
-            onError(err) {
-                if (err.message) {
-                    if (err.message !== "User rejected request") {
-                        log(err.message, err);
-                    }
-                }
-                else {
-                    log("Could not connect.", err);
-                }
-                props?.onError?.(err);
-            },
-        },
-    });
-    const { connectAsync: utxoConnectAsync } = useConnect({
-        config: utxoConfig,
-        mutation: {
-            ...props,
-            onSuccess(data, variables) {
-                props?.onSuccess?.(data, {
-                    chainId: variables?.chainId,
-                    connector: variables.connector,
-                });
-            },
-            onError(err) {
-                if (err.message) {
-                    if (err.message !== "User rejected request") {
-                        log(err.message, err);
-                    }
-                }
-                else {
-                    log("Could not connect.", err);
-                }
-                props?.onError?.(err);
-            },
-        },
-    });
-    const connect = async ({ connector, }) => {
-        switch (paymentState.connectorChainType) {
-            case ChainType.EVM:
-                await connectAsync({
-                    connector: connector,
-                });
-                break;
-            case ChainType.UTXO:
-                await utxoConnectAsync({
-                    connector: connector,
-                });
-                break;
-            case ChainType.SOL:
-                try {
-                    props?.onMutate?.({ connector });
-                    if (connected) {
-                        await disconnect();
-                    }
-                    const walletAdapter = connector;
-                    select(walletAdapter.name);
-                    props?.onSuccess?.(undefined, { connector: walletAdapter });
-                }
-                catch (error) {
-                    props?.onError?.(error);
-                }
-                break;
-            case ChainType.SUI:
-                await suiConnectAsync({
-                    wallet: connector,
-                }, {
-                    onError: props?.onError,
-                    onSuccess: (data) => {
-                        props?.onSuccess?.(data, { connector });
-                    },
-                    onSettled: (data, error) => {
-                        props?.onSettled?.(data, error);
-                    },
-                });
-                break;
-        }
-    };
-    return { connect, connected: connectedAccount.account.isConnected };
-};
-
-export { useUniversalConnect };
-//# sourceMappingURL=useUniversalConnect.js.map

package/dist/paykit/src/hooks/useUniversalConnect.js.map

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

package/dist/paykit/src/hooks/useWalletConnectModal.js

@@ -1,51 +0,0 @@
-import { useState } from 'react';
-import { walletConnect } from 'wagmi/connectors';
-import usePayContext from '../components/contexts/pay/index.js';
-import { isWalletConnectConnector } from '../utils/index.js';
-import { useConnect } from './useConnect.js';
-
-function useWalletConnectModal() {
-    const { log } = usePayContext();
-    const { connectAsync, connectors } = useConnect();
-    const [isOpen, setIsOpen] = useState(false);
-    return {
-        isOpen,
-        open: async () => {
-            // add modal styling because wagmi does not let you add styling to the modal
-            const w3mcss = document.createElement("style");
-            w3mcss.innerHTML =
-                "w3m-modal, wcm-modal{ --wcm-z-index: 2147483647; --w3m-z-index:2147483647; }";
-            document.head.appendChild(w3mcss);
-            const clientConnector = connectors.find((c) => isWalletConnectConnector(c.id));
-            if (clientConnector) {
-                try {
-                    const provider = await clientConnector.getProvider();
-                    const projectId = provider.rpc.projectId;
-                    const connector = walletConnect({
-                        projectId,
-                        showQrModal: true,
-                    });
-                    setIsOpen(true);
-                    try {
-                        await connectAsync({ connector: connector });
-                    }
-                    catch (err) {
-                        log("WalletConnect", err);
-                    }
-                    setIsOpen(false);
-                    // remove modal styling
-                    document.head.removeChild(w3mcss);
-                }
-                catch (err) {
-                    log("Could not get WalletConnect provider", err);
-                }
-            }
-            else {
-                log("No WalletConnect connector available");
-            }
-        },
-    };
-}
-
-export { useWalletConnectModal };
-//# sourceMappingURL=useWalletConnectModal.js.map

package/dist/paykit/src/hooks/useWalletConnectModal.js.map

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

package/dist/paykit/src/hooks/useWalletPaymentOptions.d.ts

@@ -1,10 +0,0 @@
-import type { ChainType } from "@coin-voyage/shared";
-import type { TokenWithBalance } from "@coin-voyage/shared/types/api";
-export declare function useWalletPaymentOptions({ address, usdRequired, chainType, }: {
-    address: string | undefined;
-    usdRequired: number | undefined;
-    chainType: ChainType | undefined;
-}): {
-    options: TokenWithBalance[] | null;
-    isLoading: boolean;
-};

package/dist/paykit/src/hooks/useWalletPaymentOptions.js

@@ -1,40 +0,0 @@
-import { useState, useEffect } from 'react';
-import { getWalletPaymentOptions } from '../server/actions/getWalletPaymentOptions.js';
-
-function useWalletPaymentOptions({ address, usdRequired, chainType, }) {
-    const [options, setOptions] = useState(null);
-    const [isLoading, setIsLoading] = useState(false);
-    useEffect(() => {
-        const refreshWalletPaymentOptions = async () => {
-            if (!address || !usdRequired || !chainType) {
-                return;
-            }
-            setOptions(null);
-            setIsLoading(true);
-            try {
-                const newOptions = await getWalletPaymentOptions({
-                    payerAddress: address,
-                    usdRequired,
-                    chainType,
-                });
-                setOptions(newOptions);
-            }
-            catch (error) {
-                console.error(error);
-            }
-            finally {
-                setIsLoading(false);
-            }
-        };
-        if (address && usdRequired != null) {
-            refreshWalletPaymentOptions();
-        }
-    }, [address, usdRequired, chainType]);
-    return {
-        options,
-        isLoading,
-    };
-}
-
-export { useWalletPaymentOptions };
-//# sourceMappingURL=useWalletPaymentOptions.js.map

package/dist/paykit/src/hooks/useWalletPaymentOptions.js.map

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

package/dist/paykit/src/hooks/useWallets.d.ts

@@ -1,2 +0,0 @@
-import type { WalletProps } from "../types/wallet";
-export declare const useWallets: () => WalletProps[];

package/dist/paykit/src/hooks/useWallets.js

@@ -1,76 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { useCombinedWallets } from '../../../crypto/src/lib/hooks/use-combined-wallets.js';
-import usePayContext from '../components/contexts/pay/index.js';
-import { walletConfigs } from '../lib/config/wallet.js';
-
-const useWallets = () => {
-    const { paymentState } = usePayContext();
-    const { installedWallets } = useCombinedWallets(paymentState.connectorChainType);
-    const context = usePayContext();
-    const wallets = installedWallets.map((wallet) => {
-        // use overrides
-        const walletId = Object.keys(walletConfigs).find(
-        // where id is comma seperated list
-        (id) => id
-            .split(",")
-            .map((i) => i.trim())
-            .indexOf(wallet.id) !== -1);
-        const c = {
-            id: wallet.id,
-            name: wallet.name ?? wallet.id,
-            icon: (jsx("img", { src: wallet.icon, alt: wallet.name, width: "100%", height: "100%" })),
-            connectors: wallet.connectors,
-            iconShape: "squircle",
-            isInstalled: true,
-        };
-        if (walletId) {
-            const wallet = walletConfigs[walletId];
-            return {
-                ...c,
-                iconConnector: wallet.icon ? (jsx("img", { src: wallet.icon.toString(), alt: wallet.name, width: "100%", height: "100%" })) : undefined,
-                ...wallet,
-            };
-        }
-        return c;
-    });
-    return (wallets
-        // remove duplicate ids
-        .filter((wallet, index, self) => self.findIndex((w) => w.id === wallet.id) === index)
-        // // Replace walletConnect's name with the one from options
-        .map((wallet) => {
-        if (wallet.id === "walletConnect") {
-            return {
-                ...wallet,
-                name: context.options?.walletConnectName || wallet.name,
-                shortName: context.options?.walletConnectName || wallet.shortName,
-            };
-        }
-        return wallet;
-    })
-        // remove wallet with id coinbaseWalletSDK if wallet with id 'com.coinbase.wallet' exists
-        .filter((wallet, _, self) => !(wallet.id === "coinbaseWalletSDK" &&
-        self.find((w) => w.id === "com.coinbase.wallet")))
-        // remove wallet with id io.metamask if wallet with id 'metaMask' exists
-        .filter((wallet, _, self) => !((wallet.id === "metaMaskSDK" || wallet.id === "metaMask") &&
-        self.find((w) => w.id === "io.metamask" || w.id === "io.metamask.mobile")))
-    // // order by isInstalled injected connectors first
-    // .sort((a, b) => {
-    //   const AisInstalled =
-    //     a.isInstalled && isInjectedConnector(a.connector.type);
-    //   const BisInstalled =
-    //     b.isInstalled && isInjectedConnector(b.connector.type);
-    //   if (AisInstalled && !BisInstalled) return -1;
-    //   if (!AisInstalled && BisInstalled) return 1;
-    //   return 0;
-    // })
-    // // move walletConnect to the end
-    // .sort((a, b) => {
-    //   if (a.id === "walletConnect") return 1;
-    //   if (b.id === "walletConnect") return -1;
-    //   return 0;
-    // })
-    );
-};
-
-export { useWallets };
-//# sourceMappingURL=useWallets.js.map

package/dist/paykit/src/hooks/useWallets.js.map

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

package/dist/paykit/src/hooks/useWindowSize.js

@@ -1,23 +0,0 @@
-import { useState, useEffect } from 'react';
-
-function useWindowSize() {
-    const [windowSize, setWindowSize] = useState({
-        width: 0,
-        height: 0,
-    });
-    useEffect(() => {
-        function handleResize() {
-            setWindowSize({
-                width: window.innerWidth,
-                height: window.innerHeight,
-            });
-        }
-        window.addEventListener("resize", handleResize);
-        handleResize();
-        return () => window.removeEventListener("resize", handleResize);
-    }, []);
-    return windowSize;
-}
-
-export { useWindowSize as default };
-//# sourceMappingURL=useWindowSize.js.map

package/dist/paykit/src/hooks/useWindowSize.js.map

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

package/dist/paykit/src/index.d.ts

@@ -1,11 +0,0 @@
-export type * as Types from "./types";
-export { ChainId, ChainType } from "@coin-voyage/shared/index";
-export { createDefaultEVMConfig } from "@coin-voyage/crypto/evm/create-default-evm-config";
-export { createDefaultBigmiConfig as createDefaultUTXOConfig } from "@coin-voyage/crypto/utxo/create-default-bigmi-config";
-export { PayButton } from "./components/pay-button";
-export { PayKitProvider } from "./providers/paykit-provider";
-export { WalletProvider } from "./providers/wallet-provider";
-export { usePayStatus } from "./hooks/usePayStatus";
-export * as themes from "./styles/themes";
-export { createSalePayOrder } from "./server/actions/payOrder";
-export { generateAuthorizationSignature } from "./utils/generate-signature";

package/dist/paykit/src/index.js

@@ -1,14 +0,0 @@
-export { ChainId, ChainType } from '../../shared/src/common/chains.js';
-import '../../shared/src/common/pay.js';
-import '../../shared/src/common/model.js';
-export { createDefaultEVMConfig } from '../../crypto/src/evm/create-default-evm-config.js';
-export { createDefaultBigmiConfig as createDefaultUTXOConfig } from '../../crypto/src/utxo/create-default-bigmi-config.js';
-export { PayButton } from './components/pay-button/index.js';
-export { PayKitProvider } from './providers/paykit-provider.js';
-export { WalletProvider } from './providers/wallet-provider.js';
-export { usePayStatus } from './hooks/usePayStatus.js';
-import * as index from './styles/themes/index.js';
-export { index as themes };
-export { createSalePayOrder } from './server/actions/payOrder.js';
-export { generateAuthorizationSignature } from './utils/generate-signature.js';
-//# sourceMappingURL=index.js.map

package/dist/paykit/src/index.js.map

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

package/dist/paykit/src/lib/config/chain.js

@@ -1,306 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import ChainIcons from '../../assets/chains.js';
-
-// Note: these rpcUrls are incomplete, and are subject to change from their respective providers
-// More RPC URLs can be found: https://chainid.network/chains.json
-const chainConfigs = [
-    {
-        id: 1,
-        name: "Ethereum",
-        logo: jsx(ChainIcons.Ethereum, {}),
-        rpcUrls: {
-            alchemy: {
-                http: ["https://eth-mainnet.g.alchemy.com/v2"],
-                webSocket: ["wss://eth-mainnet.g.alchemy.com/v2"],
-            },
-            infura: {
-                http: ["https://mainnet.infura.io/v3"],
-                webSocket: ["wss://mainnet.infura.io/ws/v3"],
-            },
-        },
-    },
-    {
-        id: 3,
-        name: "Rinkeby",
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
-        rpcUrls: {},
-    },
-    {
-        id: 4,
-        name: "Ropsten",
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
-    },
-    {
-        id: 5,
-        name: "Görli",
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
-    },
-    {
-        id: 42,
-        name: "Kovan",
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
-    },
-    {
-        id: 10,
-        name: "Optimism",
-        logo: jsx(ChainIcons.Optimism, {}),
-    },
-    {
-        id: 69, // nice
-        name: "Optimism Kovan",
-        logo: jsx(ChainIcons.Optimism, { testnet: true }),
-    },
-    {
-        id: 420, // nice
-        name: "Optimism Goerli",
-        logo: jsx(ChainIcons.Optimism, { testnet: true }),
-    },
-    {
-        id: 11155420,
-        name: "Optimism Sepolia",
-        logo: jsx(ChainIcons.Optimism, { testnet: true }),
-    },
-    {
-        id: 137,
-        name: "Polygon",
-        logo: jsx(ChainIcons.Polygon, {}),
-    },
-    {
-        id: 80001,
-        name: "Polygon Mumbai",
-        logo: jsx(ChainIcons.Polygon, { testnet: true }),
-    },
-    {
-        id: 31337,
-        name: "Hardhat",
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
-    },
-    {
-        id: 1337,
-        name: "Localhost",
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
-    },
-    {
-        id: 42161,
-        name: "Arbitrum",
-        logo: jsx(ChainIcons.Arbitrum, {}),
-        rpcUrls: {
-            alchemy: {
-                http: ["https://arb-mainnet.g.alchemy.com/v2"],
-                webSocket: ["wss://arb-mainnet.g.alchemy.com/v2"],
-            },
-            infura: {
-                http: ["https://arbitrum-mainnet.infura.io/v3"],
-                webSocket: ["wss://arbitrum-mainnet.infura.io/ws/v3"],
-            },
-        },
-    },
-    {
-        id: 421611,
-        name: "Arbitrum Rinkeby",
-        logo: jsx(ChainIcons.Arbitrum, { testnet: true }),
-    },
-    {
-        id: 421613,
-        name: "Arbitrum Goerli",
-        logo: jsx(ChainIcons.Arbitrum, { testnet: true }),
-        rpcUrls: {
-            alchemy: {
-                http: ["https://arb-goerli.g.alchemy.com/v2"],
-                webSocket: ["wss://arb-goerli.g.alchemy.com/v2"],
-            },
-            infura: {
-                http: ["https://arbitrum-goerli.infura.io/v3"],
-                webSocket: ["wss://arbitrum-goerli.infura.io/ws/v3"],
-            },
-        },
-    },
-    {
-        id: 40,
-        name: "Telos",
-        logo: jsx(ChainIcons.Telos, {}),
-    },
-    {
-        id: 41,
-        name: "Telos Testnet",
-        logo: jsx(ChainIcons.Telos, { testnet: true }),
-    },
-    {
-        id: 1313161554,
-        name: "Aurora",
-        logo: jsx(ChainIcons.Aurora, {}),
-    },
-    {
-        id: 1313161555,
-        name: "Aurora Testnet",
-        logo: jsx(ChainIcons.Aurora, { testnet: true }),
-    },
-    {
-        id: 43114,
-        name: "Avalanche",
-        logo: jsx(ChainIcons.Avalanche, {}),
-    },
-    {
-        id: 43113,
-        name: "Avalanche Fuji",
-        logo: jsx(ChainIcons.Avalanche, { testnet: true }),
-    },
-    {
-        id: 31337,
-        name: "Foundry",
-        logo: jsx(ChainIcons.Foundry, { testnet: true }),
-    },
-    {
-        id: 100,
-        name: "Gnosis",
-        logo: jsx(ChainIcons.Gnosis, {}),
-    },
-    {
-        id: 9001,
-        name: "Evmos",
-        logo: jsx(ChainIcons.Evmos, {}),
-    },
-    {
-        id: 9000,
-        name: "Evmos Testnet",
-        logo: jsx(ChainIcons.Evmos, { testnet: true }),
-    },
-    {
-        id: 56,
-        name: "BNB Smart Chain",
-        logo: jsx(ChainIcons.BinanceSmartChain, {}),
-    },
-    {
-        id: 97,
-        name: "Binance Smart Chain Testnet",
-        logo: jsx(ChainIcons.BinanceSmartChain, { testnet: true }),
-    },
-    {
-        id: 11155111,
-        name: "Sepolia",
-        logo: jsx(ChainIcons.Sepolia, {}),
-    },
-    {
-        id: 841,
-        name: "Taraxa",
-        logo: jsx(ChainIcons.Taraxa, {}),
-    },
-    {
-        id: 842,
-        name: "Taraxa Testnet",
-        logo: jsx(ChainIcons.Taraxa, { testnet: true }),
-    },
-    {
-        id: 324,
-        name: "zkSync",
-        logo: jsx(ChainIcons.zkSync, {}),
-    },
-    {
-        id: 280,
-        name: "zkSync Testnet",
-        logo: jsx(ChainIcons.zkSync, { testnet: true }),
-    },
-    {
-        id: 42220,
-        name: "Celo",
-        logo: jsx(ChainIcons.Celo, {}),
-    },
-    {
-        id: 44787,
-        name: "Celo Alfajores",
-        logo: jsx(ChainIcons.Celo, { testnet: true }),
-    },
-    {
-        id: 7700,
-        name: "Canto",
-        logo: jsx(ChainIcons.Canto, {}),
-    },
-    {
-        id: 250,
-        name: "Fantom",
-        logo: jsx(ChainIcons.Fantom, {}),
-    },
-    {
-        id: 4002,
-        name: "Fantom Testnet",
-        logo: jsx(ChainIcons.Fantom, { testnet: true }),
-    },
-    {
-        id: 14,
-        name: "Flare",
-        logo: jsx(ChainIcons.Flare, {}),
-    },
-    {
-        id: 114,
-        name: "Coston2",
-        logo: jsx(ChainIcons.Flare, {}),
-    },
-    {
-        id: 314,
-        name: "Filecoin",
-        logo: jsx(ChainIcons.Filecoin, {}),
-    },
-    {
-        id: 3141,
-        name: "Filecoin Hyperspace",
-        logo: jsx(ChainIcons.Filecoin, { testnet: true }),
-    },
-    {
-        id: 314159,
-        name: "Filecoin Calibration",
-        logo: jsx(ChainIcons.Filecoin, { testnet: true }),
-    },
-    {
-        id: 1088,
-        name: "Metis",
-        logo: jsx(ChainIcons.Metis, {}),
-    },
-    {
-        id: 599,
-        name: "Metis Goerli",
-        logo: jsx(ChainIcons.Metis, { testnet: true }),
-    },
-    {
-        id: 4689,
-        name: "IoTeX",
-        logo: jsx(ChainIcons.IoTeX, {}),
-    },
-    {
-        id: 4690,
-        name: "IoTeX Testnet",
-        logo: jsx(ChainIcons.IoTeX, { testnet: true }),
-    },
-    {
-        id: 8453,
-        name: "Base",
-        logo: jsx(ChainIcons.Base, {}),
-    },
-    {
-        id: 84531,
-        name: "Base Goerli",
-        logo: jsx(ChainIcons.Base, { testnet: true }),
-    },
-    {
-        id: 84532,
-        name: "Base Sepolia",
-        logo: jsx(ChainIcons.Base, { testnet: true }),
-    },
-    {
-        id: 7777777,
-        name: "Zora",
-        logo: jsx(ChainIcons.Zora, {}),
-    },
-    {
-        id: 999999999,
-        name: "Zora Sepolia",
-        logo: jsx(ChainIcons.Zora, { testnet: true }),
-    },
-    {
-        id: 999,
-        name: "Zora Goerli Testnet",
-        logo: jsx(ChainIcons.Zora, { testnet: true }),
-    },
-];
-
-export { chainConfigs };
-//# sourceMappingURL=chain.js.map

package/dist/paykit/src/lib/config/chain.js.map

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

package/dist/paykit/src/lib/config/default-theme.js

@@ -1,6 +0,0 @@
-var defaultTheme = {
-    mobileWidth: 560,
-};
-
-export { defaultTheme as default };
-//# sourceMappingURL=default-theme.js.map