@daimo/pay 1.6.1 → 1.6.3

package/build/src/utils/format.js

@@ -1,83 +0,0 @@
-import { formatUnits } from 'viem';
-
-const USD_DECIMALS = 2;
-/**
- * Round a number to a given number of decimal places
- *
- * @param round - The rounding strategy to use:
- * - "up": Always rounds up to the next decimal place (ceiling)
- * - "down": Always rounds down to the previous decimal place (floor)
- * - "nearest": Rounds to the nearest decimal place (standard rounding)
- */
-function roundDecimals(value, decimals, round) {
-    const factor = 10 ** decimals;
-    const multiplied = value * factor;
-    let rounded;
-    if (round === "up") {
-        rounded = Math.ceil(multiplied);
-    }
-    else if (round === "down") {
-        rounded = Math.floor(multiplied);
-    }
-    else {
-        rounded = Math.round(multiplied);
-    }
-    return (rounded / factor).toFixed(decimals);
-}
-/**
- * Format a number as a USD amount
- *
- * @param usd - The USD amount to format
- * @param round - The rounding strategy to use ("up", "down", or "nearest")
- * @returns The formatted USD amount
- */
-function formatUsd(usd, round = "down") {
-    return new Intl.NumberFormat("en-US", {
-        style: "currency",
-        currency: "USD",
-    }).format(Number(roundUsd(usd, round)));
-}
-/**
- * Round a USD amount to `USD_DECIMALS` precision
- */
-function roundUsd(usd, round = "down") {
-    return roundDecimals(usd, USD_DECIMALS, round);
-}
-/**
- * Round a token amount to `displayDecimals` precision
- */
-function roundTokenAmount(amount, token, round = "down") {
-    return roundDecimals(Number(formatUnits(BigInt(amount), token.decimals)), token.displayDecimals, round);
-}
-/**
- * Round a token amount in units to `displayDecimals` precision
- */
-function roundTokenAmountUnits(amountUnits, token, round = "down") {
-    return roundDecimals(amountUnits, token.displayDecimals, round);
-}
-/**
- * Convert a USD amount to a token amount with `displayDecimals` precision
- *
- * @param usd - The USD amount to convert
- * @param token - The token to convert to
- * @param round - The rounding strategy to use ("up", "down", or "nearest")
- * @returns The token amount
- */
-function usdToRoundedTokenAmount(usd, token, round = "down") {
-    return roundTokenAmountUnits(usd / token.usd, token, round);
-}
-/**
- * Convert a token amount to a USD amount with `USD_DECIMALS` precision
- *
- * @param amount - The token amount to convert
- * @param token - The token to convert from
- * @param round - The rounding strategy to use ("up", "down", or "nearest")
- * @returns The formatted USD amount
- */
-function tokenAmountToRoundedUsd(amount, token, round = "nearest") {
-    const amountUnits = formatUnits(BigInt(amount), token.decimals);
-    return roundUsd(Number(amountUnits) * token.usd, round);
-}
-
-export { USD_DECIMALS, formatUsd, roundDecimals, roundTokenAmount, roundTokenAmountUnits, roundUsd, tokenAmountToRoundedUsd, usdToRoundedTokenAmount };
-//# sourceMappingURL=format.js.map

package/build/src/utils/format.js.map

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

package/build/src/utils/index.js

@@ -1,39 +0,0 @@
-import { detect } from 'detect-browser';
-import React from 'react';
-
-const detectBrowser = () => {
-    const browser = detect();
-    return browser?.name ?? "";
-};
-const detectOS = () => {
-    const browser = detect();
-    return browser?.os ?? "";
-};
-const isIOS = () => {
-    const os = detectOS();
-    return os.toLowerCase().includes("ios");
-};
-const isAndroid = () => {
-    const os = detectOS();
-    return os.toLowerCase().includes("android");
-};
-const isMobile = () => {
-    return isAndroid() || isIOS();
-};
-function flattenChildren(children) {
-    const childrenArray = React.Children.toArray(children);
-    return childrenArray.reduce((flatChildren, child) => {
-        if (child.type === React.Fragment) {
-            return flatChildren.concat(flattenChildren(child.props.children));
-        }
-        flatChildren.push(child);
-        return flatChildren;
-    }, []);
-}
-const isWalletConnectConnector = (connectorId) => connectorId === "walletConnect";
-const isCoinbaseWalletConnector = (connectorId) => connectorId === "coinbaseWalletSDK";
-const isSafeConnector = (connectorId) => connectorId === "safe";
-const isInjectedConnector = (connectorId) => connectorId === "injected";
-
-export { detectBrowser, detectOS, flattenChildren, isAndroid, isCoinbaseWalletConnector, isInjectedConnector, isMobile, isSafeConnector, isWalletConnectConnector };
-//# sourceMappingURL=index.js.map

package/build/src/utils/index.js.map

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

package/build/src/utils/p3.js

@@ -1,16 +0,0 @@
-import 'styled-components';
-
-const hexToP3 = (hex) => {
-    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-    if (result == null)
-        return hex;
-    const values = {
-        r: parseInt(result[1], 16),
-        g: parseInt(result[2], 16),
-        b: parseInt(result[3], 16),
-    };
-    return `color(display-p3 ${values.r / 255} ${values.g / 255} ${values.b / 255})`;
-};
-
-export { hexToP3 };
-//# sourceMappingURL=p3.js.map

package/build/src/utils/p3.js.map

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

package/build/src/utils/platform.js

@@ -1,13 +0,0 @@
-function detectPlatform(ua) {
-    // From https://dev.to/konyu/using-javascript-to-determine-whether-the-client-is-ios-or-android-4i1j
-    if (/android/i.test(ua)) {
-        return "android";
-    }
-    else if (/iPhone|iPod|iPad/.test(ua)) {
-        return "ios";
-    }
-    return "other";
-}
-
-export { detectPlatform };
-//# sourceMappingURL=platform.js.map

package/build/src/utils/platform.js.map

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

package/build/src/utils/supportUrl.js

@@ -1,18 +0,0 @@
-import { writeDaimoPayOrderID } from '@daimo/pay-common';
-import { daimoPayVersion } from './exports.js';
-
-function getSupportUrl(daimoPayOrder, screen) {
-    const payId = daimoPayOrder == null ? null : writeDaimoPayOrderID(daimoPayOrder.id);
-    const email = "support@daimo.com";
-    const subject = `Support${payId ? ` #${payId}` : ""}`;
-    let body = [
-        `Transaction: ${screen}`,
-        `Version: ${daimoPayVersion}`,
-        ``,
-        `Tell us how we can help`,
-    ].join("\n");
-    return `mailto:${email}?subject=${encodeURIComponent(subject)}&body=${encodeURIComponent(body)}`;
-}
-
-export { getSupportUrl };
-//# sourceMappingURL=supportUrl.js.map

package/build/src/utils/supportUrl.js.map

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

package/build/src/utils/trpc.js

@@ -1,19 +0,0 @@
-import { createTRPCClient, httpBatchLink } from '@trpc/client';
-import { daimoPayVersion } from './exports.js';
-
-function createTrpcClient(apiUrl, sessionId) {
-    return createTRPCClient({
-        links: [
-            httpBatchLink({
-                url: apiUrl,
-                headers: {
-                    "x-pay-version": daimoPayVersion,
-                    "x-session-id": sessionId,
-                },
-            }),
-        ],
-    });
-}
-
-export { createTrpcClient };
-//# sourceMappingURL=trpc.js.map

package/build/src/utils/trpc.js.map

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

package/build/src/utils/validateInput.js

@@ -1,36 +0,0 @@
-/**
- * Returns true if the value is a valid number.
- * @param value The value to validate.
- * @param maxDecimals The maximum number of decimal places.
- * @returns True if the value is a valid number, false otherwise.
- */
-function isValidNumber(value, maxDecimals) {
-    if (value.length === 0) {
-        return false;
-    }
-    // Test that the value is digits, followed by an optional decimal, followed
-    // by more digits
-    const match = /^\d*\.?(\d*)$/.exec(value);
-    if (match == null)
-        return false;
-    // Check that the number of digits after the decimal is less than or equal to
-    // maxDecimals
-    return maxDecimals == null || match[1].length <= maxDecimals;
-}
-/**
- * Sanitize a number input.
- * - Remove all non-numeric and non-decimal characters
- * - If the value is empty, return "0"
- * - Parse into a number
- * @param value The value to sanitize.
- * @returns The sanitized value.
- */
-function sanitizeNumber(value) {
-    const cleaned = value.replace(/[^0-9.]/g, "");
-    if (!cleaned || cleaned === "." || !/^\d*\.?\d*$/.test(cleaned))
-        return "0";
-    return cleaned.startsWith(".") ? `0${cleaned}` : cleaned;
-}
-
-export { isValidNumber, sanitizeNumber };
-//# sourceMappingURL=validateInput.js.map

package/build/src/utils/validateInput.js.map

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

package/build/src/utils/wallets.js

@@ -1,14 +0,0 @@
-const isWalletInstalled = (name) => {
-    if (typeof window === "undefined")
-        return false;
-    const { ethereum } = window;
-    return !!(ethereum?.[`is${name}`] ||
-        (ethereum?.providers &&
-            ethereum?.providers.find((provider) => provider?.[`is${name}`])));
-};
-const isFamily = () => isWalletInstalled("Family");
-const isRainbow = () => isWalletInstalled("Rainbow");
-const isZerion = () => isWalletInstalled("Zerion");
-
-export { isFamily, isRainbow, isWalletInstalled, isZerion };
-//# sourceMappingURL=wallets.js.map

package/build/src/utils/wallets.js.map

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

package/build/src/wallets/index.js

@@ -1,32 +0,0 @@
-import { injected } from '@wagmi/connectors';
-import { walletConfigs } from './walletConfigs.js';
-
-/** Ethereum wallets, by name. */
-const wallets = Object.keys(walletConfigs).reduce((acc, key) => {
-    const config = walletConfigs[key];
-    if (!config?.getWalletConnectDeeplink)
-        return acc;
-    const target = key.split(",")[0].trim();
-    const flag = config.name?.replace("Wallet", "").replace(" ", "") ??
-        target[0].toUpperCase() + target.slice(1);
-    const connector = injected({
-        target: {
-            id: target,
-            name: config.name ?? config.shortName ?? key,
-            provider: (w) => w?.ethereum?.[`is${flag}`],
-        },
-    });
-    const name = (config.name ?? config.shortName ?? key)
-        .toLowerCase()
-        // capitalize first letter
-        .replace(/(?:^|\s)\S/g, (a) => a.toUpperCase())
-        // remove spaces
-        .replace(/\s/g, "")
-        // lowercase first letter
-        .replace(/(?:^|\s)\S/g, (a) => a.toLowerCase());
-    acc[name] = connector;
-    return acc;
-}, {});
-
-export { wallets };
-//# sourceMappingURL=index.js.map

package/build/src/wallets/index.js.map

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

package/build/src/wallets/useWallets.js

@@ -1,90 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { usePayContext } from '../components/DaimoPay.js';
-import { useConnectors } from '../hooks/useConnectors.js';
-import { isCoinbaseWalletConnector, isInjectedConnector } from '../utils/index.js';
-import { walletConfigs } from './walletConfigs.js';
-
-const useWallet = (id) => {
-    const wallets = useWallets();
-    const wallet = wallets.find((c) => c.id === id);
-    if (!wallet)
-        return null;
-    return wallet;
-};
-const useWallets = () => {
-    const connectors = useConnectors();
-    const context = usePayContext();
-    const wallets = connectors.map((connector) => {
-        // use overrides
-        const walletId = Object.keys(walletConfigs).find(
-        // where id is comma seperated list
-        (id) => id
-            .split(",")
-            .map((i) => i.trim())
-            .indexOf(connector.id) !== -1);
-        const c = {
-            id: connector.id,
-            name: connector.name ?? connector.id ?? connector.type,
-            icon: (jsx("img", { src: connector.icon, alt: connector.name, width: "100%", height: "100%" })),
-            connector,
-            iconShape: "squircle",
-            isInstalled: connector.type === "mock" ||
-                (connector.type === "injected" && connector.id !== "metaMask") ||
-                connector.type === "farcasterFrame" ||
-                isCoinbaseWalletConnector(connector.id), // always run coinbase wallet SDK
-        };
-        if (walletId) {
-            const wallet = walletConfigs[walletId];
-            return {
-                ...c,
-                iconConnector: connector.icon ? (jsx("img", { src: connector.icon, alt: connector.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, index, 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, index, self) => !((wallet.id === "metaMaskSDK" || wallet.id === "metaMask") &&
-        self.find((w) => w.id === "io.metamask" || w.id === "io.metamask.mobile")))
-        // remove wallet with id 'com.warpcast.mobile' if wallet with id 'farcaster' exists
-        .filter((wallet, index, self) => !(wallet.id === "com.warpcast.mobile" &&
-        self.find((w) => w.id === "farcaster")))
-        // 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 { useWallet, useWallets };
-//# sourceMappingURL=useWallets.js.map

package/build/src/wallets/useWallets.js.map

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