@openfort/react 0.3.2 → 1.0.0

package/build/wagmi/components/ChainSelectDropdown/index.js

@@ -0,0 +1,144 @@
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { AnimatePresence } from 'framer-motion';
+import { useState, useRef, useEffect, useCallback, useLayoutEffect } from 'react';
+import useMeasure from 'react-use-measure';
+import Portal from '../../../components/Common/Portal/index.js';
+import { useThemeContext } from '../../../components/ConnectKitThemeProvider/ConnectKitThemeProvider.js';
+import { useOpenfort } from '../../../components/Openfort/useOpenfort.js';
+import FocusTrap from '../../../hooks/useFocusTrap.js';
+import useLocales from '../../../hooks/useLocales.js';
+import useLockBodyScroll from '../../../hooks/useLockBodyScroll.js';
+import { ResetContainer } from '../../../styles/index.js';
+import ChainSelectList from '../ChainSelectList/index.js';
+import { DropdownWindow, DropdownOverlay, DropdownContainer, DropdownHeading } from './styles.js';
+
+const ChainSelectDropdown = ({ children, open, onClose, offsetX = 0, offsetY = 8 }) => {
+    var _a, _b, _c;
+    const context = useOpenfort();
+    const themeContext = useThemeContext();
+    const locales = useLocales();
+    const [offset, _setOffset] = useState({ x: 0, y: 0 });
+    useLockBodyScroll(open);
+    const contentRef = useRef(null);
+    useEffect(() => {
+        const listener = (e) => {
+            var _a, _b, _c;
+            if (!open)
+                return;
+            if (e.key === 'Escape')
+                onClose();
+            if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+                if (!contentRef.current)
+                    return;
+                e.preventDefault();
+                const focusableEls = (_a = contentRef.current) === null || _a === void 0 ? void 0 : _a.querySelectorAll(`
+            a[href]:not(:disabled),
+            button:not(:disabled),
+            textarea:not(:disabled),
+            input[type="text"]:not(:disabled),
+            input[type="radio"]:not(:disabled),
+            input[type="checkbox"]:not(:disabled),
+            select:not(:disabled)
+          `), firstFocusableEl = focusableEls[0], lastFocusableEl = focusableEls[focusableEls.length - 1];
+                if (e.key === 'ArrowUp') {
+                    if (document.activeElement === firstFocusableEl) {
+                        lastFocusableEl.focus();
+                    }
+                    else {
+                        let focusItem = (_b = document === null || document === void 0 ? void 0 : document.activeElement) === null || _b === void 0 ? void 0 : _b.previousSibling;
+                        if (!focusItem)
+                            focusItem = lastFocusableEl;
+                        while (focusItem.disabled)
+                            focusItem = focusItem.previousSibling;
+                        focusItem.focus();
+                    }
+                }
+                else {
+                    if (document.activeElement === lastFocusableEl) {
+                        firstFocusableEl.focus();
+                    }
+                    else {
+                        let focusItem = (_c = document === null || document === void 0 ? void 0 : document.activeElement) === null || _c === void 0 ? void 0 : _c.nextSibling;
+                        if (!focusItem)
+                            focusItem = firstFocusableEl;
+                        while (focusItem.disabled)
+                            focusItem = focusItem.nextSibling;
+                        focusItem.focus();
+                    }
+                }
+            }
+        };
+        document.addEventListener('keydown', listener);
+        return () => {
+            document.removeEventListener('keydown', listener);
+        };
+    }, [open]);
+    const targetRef = useRef(null);
+    const innerRef = useCallback((node) => {
+        if (!node)
+            return;
+        targetRef.current = node;
+        refresh();
+    }, [open]);
+    const [ref, bounds] = useMeasure({
+        debounce: 120, // waits until modal transition has finished before measuring
+        offsetSize: true,
+        scroll: true,
+    });
+    const refresh = () => {
+        if (!targetRef.current ||
+            bounds.top + bounds.bottom + bounds.left + bounds.right + bounds.height + bounds.width === 0) {
+            return;
+        }
+        const x = bounds.left + offsetX;
+        const y = bounds.top + bounds.height + offsetY;
+        targetRef.current.style.left = `${x}px`;
+        targetRef.current.style.top = `${y}px`;
+    };
+    const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+    useIsomorphicLayoutEffect(refresh, [targetRef.current, bounds, open]);
+    useEffect(refresh, [open, targetRef.current]);
+    const onScroll = onClose;
+    const onResize = onClose;
+    useEffect(() => {
+        refresh();
+        window.addEventListener('scroll', onScroll);
+        window.addEventListener('resize', onResize);
+        return () => {
+            window.removeEventListener('scroll', onScroll);
+            window.removeEventListener('resize', onResize);
+        };
+    }, []);
+    return (jsxs(Fragment, { children: [jsx("div", { ref: ref, children: children }), jsx(AnimatePresence, { children: open && (jsx(Portal, { children: jsx(ResetContainer, { "$useTheme": (_a = themeContext.theme) !== null && _a !== void 0 ? _a : context.uiConfig.theme, "$useMode": (_b = themeContext.mode) !== null && _b !== void 0 ? _b : context.mode, "$customTheme": (_c = themeContext.customTheme) !== null && _c !== void 0 ? _c : themeContext.customTheme, children: jsx(FocusTrap, { children: jsxs(DropdownWindow, { ref: contentRef, children: [jsx(DropdownOverlay, { onClick: onClose }), jsxs(DropdownContainer, { ref: innerRef, style: {
+                                            left: offset.x,
+                                            top: offset.y,
+                                        }, initial: 'collapsed', animate: 'open', exit: 'collapsed', variants: {
+                                            collapsed: {
+                                                transformOrigin: '0 0',
+                                                opacity: 0,
+                                                scale: 0.96,
+                                                z: 0.01,
+                                                y: -4,
+                                                x: 0,
+                                                transition: {
+                                                    duration: 0.1,
+                                                },
+                                            },
+                                            open: {
+                                                transformOrigin: '0 0',
+                                                willChange: 'opacity,transform',
+                                                opacity: 1,
+                                                scale: 1,
+                                                z: 0.01,
+                                                y: 0,
+                                                x: 0,
+                                                transition: {
+                                                    ease: [0.76, 0, 0.24, 1],
+                                                    duration: 0.15,
+                                                },
+                                            },
+                                        }, children: [jsx(DropdownHeading, { children: locales.switchNetworks }), jsx(ChainSelectList, {})] })] }) }) }) })) })] }));
+};
+
+export { ChainSelectDropdown as default };
+//# sourceMappingURL=index.js.map

package/build/wagmi/components/ChainSelectDropdown/index.js.map

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

package/build/wagmi/components/ChainSelectDropdown/styles.js

@@ -0,0 +1,47 @@
+import { motion } from 'framer-motion';
+import styled from '../../../styles/styled/index.js';
+
+const DropdownWindow = styled(motion.div) `
+  z-index: 2147483647;
+  position: fixed;
+  inset: 0;
+`;
+const DropdownOverlay = styled(motion.div) `
+  position: absolute;
+  inset: 0;
+`;
+const DropdownContainer = styled(motion.div) `
+  --shadow: 0px 2px 15px rgba(0, 0, 0, 0.15);
+  --background: var(--ck-dropdown-background, var(--ck-tooltip-background));
+  --border-radius: var(
+    --ck-dropdown-border-radius,
+    var(--ck-tooltip-border-radius, 12px)
+  );
+
+  pointer-events: auto;
+  z-index: 2147483647;
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  max-width: fit-content;
+  padding: 14px 16px 16px;
+  color: var(--ck-dropdown-color, var(--ck-tooltip-color));
+  background: var(--background);
+  box-shadow: var(
+    --ck-dropdown-box-shadow,
+    var(--ck-tooltip-shadow, var(--shadow))
+  );
+  border-radius: var(--border-radius);
+`;
+const DropdownHeading = styled(motion.div) `
+  padding: 0 0 6px;
+  font-size: 14px;
+  line-height: 20px;
+  font-weight: 400;
+  user-select: none;
+  color: var(--ck-dropdown-color, var(--ck-tooltip-color));
+`;
+
+export { DropdownContainer, DropdownHeading, DropdownOverlay, DropdownWindow };
+//# sourceMappingURL=styles.js.map

package/build/wagmi/components/ChainSelectDropdown/styles.js.map

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

package/build/wagmi/components/ChainSelectList/index.js

@@ -0,0 +1,109 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { motion, AnimatePresence } from 'framer-motion';
+import { useState, useEffect, useId } from 'react';
+import { useAccount, useChainId, useSwitchChain } from 'wagmi';
+import ChainIcons from '../../../assets/chains.js';
+import Alert from '../../../components/Common/Alert/index.js';
+import { useOpenfort } from '../../../components/Openfort/useOpenfort.js';
+import { chainConfigs } from '../../../constants/chainConfigs.js';
+import useLocales from '../../../hooks/useLocales.js';
+import { isMobile, isCoinbaseWalletConnector } from '../../../utils/index.js';
+import { SwitchNetworksContainer, ChainButtonContainer, ChainButtons, ChainButton, ChainLogoContainer, ChainLogoSpinner, ChainIcon, ChainButtonStatus, ChainButtonBg } from './styles.js';
+
+const Spinner = () => {
+    const id = useId();
+    return (jsxs("svg", { "aria-hidden": "true", width: "36", height: "36", viewBox: "0 0 36 36", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [jsx("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M2 16.75C2.69036 16.75 3.25 17.3096 3.25 18V19C3.25 26.5939 9.40609 32.75 17 32.75V35.25C8.02537 35.25 0.75 27.9746 0.75 19V18C0.75 17.3096 1.30964 16.75 2 16.75Z", fill: `url(#paint0_linear_${id})` }), jsx("defs", { children: jsxs("linearGradient", { id: `paint0_linear_${id}`, x1: "2", y1: "19.4884", x2: "16.8752", y2: "33.7485", gradientUnits: "userSpaceOnUse", children: [jsx("stop", { stopColor: "var(--ck-spinner-color)" }), jsx("stop", { offset: "1", stopColor: "var(--ck-spinner-color)", stopOpacity: "0" })] }) })] }));
+};
+const ChainSelectList = ({ variant }) => {
+    const { connector } = useAccount();
+    const activeChainId = useChainId();
+    const { chains, isPending: bridgeIsPending, switchChain: switchChainFn, error: bridgeError } = useSwitchChain();
+    const [pendingChainId, setPendingChainId] = useState(undefined);
+    const locales = useLocales({});
+    const mobile = isMobile();
+    const { triggerResize } = useOpenfort();
+    const chainList = chains.map((ch) => ({ id: ch.id, name: ch.name }));
+    // Clear pending state when switch completes so next switch shows loading animation
+    useEffect(() => {
+        if (!bridgeIsPending)
+            setPendingChainId(undefined);
+    }, [bridgeIsPending]);
+    // biome-ignore lint/complexity/useLiteralKeys: SwitchChainErrorType doesn't expose 'code' property but it exists at runtime
+    const isError = (bridgeError === null || bridgeError === void 0 ? void 0 : bridgeError['code']) === 4902; // Wallet cannot switch networks
+    const disabled = isError || !switchChainFn;
+    const handleSwitchNetwork = (chainId) => {
+        if (switchChainFn) {
+            setPendingChainId(chainId);
+            switchChainFn({ chainId });
+        }
+    };
+    return (jsxs(SwitchNetworksContainer, { style: { marginBottom: switchChainFn !== undefined ? -8 : 0 }, children: [jsx(ChainButtonContainer, { children: jsx(ChainButtons, { children: chainList.map((x) => {
+                        var _a;
+                        const c = chainConfigs.find((ch) => ch.id === x.id);
+                        const ch = { ...c, ...x };
+                        return (jsxs(ChainButton, { "$variant": variant, disabled: disabled || ch.id === activeChainId || (bridgeIsPending && pendingChainId === ch.id), onClick: () => handleSwitchNetwork === null || handleSwitchNetwork === void 0 ? void 0 : handleSwitchNetwork(ch.id), style: {
+                                opacity: disabled && ch.id !== activeChainId ? 0.4 : undefined,
+                            }, children: [jsxs("span", { style: {
+                                        display: 'flex',
+                                        alignItems: 'center',
+                                        justifyContent: 'flex-start',
+                                        gap: 12,
+                                        color: ch.id === activeChainId
+                                            ? 'var(--ck-dropdown-active-color, inherit)'
+                                            : 'var(--ck-dropdown-color, inherit)',
+                                    }, children: [jsxs(ChainLogoContainer, { children: [jsx(ChainLogoSpinner, { initial: { opacity: 0 }, animate: {
+                                                        opacity: bridgeIsPending && pendingChainId === ch.id ? 1 : 0,
+                                                    }, transition: {
+                                                        ease: [0.76, 0, 0.24, 1],
+                                                        duration: 0.15,
+                                                        delay: 0.1,
+                                                    }, children: jsx(motion.div, { animate: mobile &&
+                                                            isCoinbaseWalletConnector(connector === null || connector === void 0 ? void 0 : connector.id) &&
+                                                            bridgeIsPending &&
+                                                            pendingChainId === ch.id
+                                                            ? {
+                                                                opacity: [1, 0],
+                                                                transition: { delay: 4, duration: 3 },
+                                                            }
+                                                            : { opacity: 1 }, children: jsx(Spinner, {}) }, `${ch === null || ch === void 0 ? void 0 : ch.id}-${ch === null || ch === void 0 ? void 0 : ch.name}`) }), jsx(ChainIcon, { children: (_a = ch.logo) !== null && _a !== void 0 ? _a : jsx(ChainIcons.UnknownChain, {}) })] }), ch.name] }), variant !== 'secondary' && (jsx(ChainButtonStatus, { children: jsxs(AnimatePresence, { initial: false, exitBeforeEnter: true, children: [ch.id === activeChainId && (jsx(motion.span, { style: {
+                                                    color: 'var(--ck-dropdown-active-color, var(--ck-focus-color))',
+                                                    display: 'block',
+                                                    position: 'relative',
+                                                }, initial: { opacity: 0, x: -4 }, animate: { opacity: 1, x: 0 }, exit: {
+                                                    opacity: 0,
+                                                    x: 4,
+                                                    transition: { duration: 0.1, delay: 0 },
+                                                }, transition: {
+                                                    ease: [0.76, 0, 0.24, 1],
+                                                    duration: 0.3,
+                                                    delay: 0.2,
+                                                }, children: locales.connected }, `connected-${ch.id}`)), bridgeIsPending && pendingChainId === ch.id && (jsx(motion.span, { style: {
+                                                    color: 'var(--ck-dropdown-pending-color, inherit)',
+                                                    display: 'block',
+                                                    position: 'relative',
+                                                }, initial: { opacity: 0, x: -4 }, animate: { opacity: 1, x: 0 }, exit: { opacity: 0, x: 4 }, transition: {
+                                                    ease: [0.76, 0, 0.24, 1],
+                                                    duration: 0.3,
+                                                    delay: 0.1,
+                                                }, children: jsx(motion.span, { animate: mobile && isCoinbaseWalletConnector(connector === null || connector === void 0 ? void 0 : connector.id)
+                                                        ? {
+                                                            opacity: [1, 0],
+                                                            transition: { delay: 4, duration: 4 },
+                                                        }
+                                                        : undefined, children: locales.approveInWallet }) }, `approve-${ch.id}`))] }) })), variant === 'secondary' ? (jsx(ChainButtonBg, { initial: false, animate: {
+                                        opacity: ch.id === activeChainId ? 1 : 0,
+                                    }, transition: {
+                                        duration: 0.3,
+                                        ease: 'easeOut',
+                                    } })) : (ch.id === activeChainId && (jsx(ChainButtonBg, { layoutId: "activeChain", layout: "position", transition: {
+                                        duration: 0.3,
+                                        ease: 'easeOut',
+                                    } })))] }, `${ch === null || ch === void 0 ? void 0 : ch.id}-${ch === null || ch === void 0 ? void 0 : ch.name}`));
+                    }) }) }), jsx(AnimatePresence, { children: isError && (jsx(motion.div, { initial: { opacity: 0 }, animate: { opacity: 1 }, exit: { opacity: 0 }, transition: {
+                        ease: [0.76, 0, 0.24, 1],
+                        duration: 0.3,
+                    }, onAnimationStart: triggerResize, onAnimationComplete: triggerResize, children: jsx("div", { style: { paddingTop: 10, paddingBottom: 8 }, children: jsxs(Alert, { children: [locales.warnings_walletSwitchingUnsupported, " ", locales.warnings_walletSwitchingUnsupportedResolve] }) }) })) })] }));
+};
+
+export { ChainSelectList as default };
+//# sourceMappingURL=index.js.map

package/build/wagmi/components/ChainSelectList/index.js.map

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

package/build/wagmi/components/ChainSelectList/styles.js

@@ -0,0 +1,225 @@
+import { motion } from 'framer-motion';
+import { css } from 'styled-components';
+import defaultTheme from '../../../constants/defaultTheme.js';
+import styled from '../../../styles/styled/index.js';
+
+const SwitchNetworksContainer = styled.div `
+  display: flex;
+  flex-direction: column;
+
+  @media only screen and (max-width: ${defaultTheme.mobileWidth}px) {
+    flex-direction: column-reverse;
+  }
+`;
+const ChainIcon = styled(motion.div) `
+  display: block;
+  position: relative;
+  border-radius: 12px;
+  overflow: hidden;
+  width: 24px;
+  height: 24px;
+  min-width: 24px;
+  min-height: 24px;
+  background: var(--ck-body-background);
+  svg {
+    border-radius: inherit;
+    display: block;
+    position: relative;
+    transform: translate3d(0, 0, 0);
+    width: 100%;
+    height: auto;
+  }
+  ${(props) => props.$empty &&
+    css `
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      &:before {
+        content: '?';
+        color: var(--ck-body-color-muted);
+        font-weight: bold;
+        font-family: var(--ck-font-family);
+      }
+    `}
+  @media only screen and (max-width: ${defaultTheme.mobileWidth}px) {
+    border-radius: 16px;
+    width: 32px;
+    height: 32px;
+  }
+`;
+const ChainLogoContainer = styled(motion.div) `
+  position: relative;
+`;
+const ChainLogoSpinner = styled(motion.div) `
+  position: absolute;
+  inset: -6px;
+  animation: rotateSpinner 1200ms linear infinite;
+  pointer-events: none;
+  svg {
+    display: block;
+    position: relative;
+    transform: translate3d(0, 0, 0);
+    width: 100%;
+    height: auto;
+  }
+  @keyframes rotateSpinner {
+    0% {
+      transform: rotate(0deg);
+    }
+    100% {
+      transform: rotate(360deg);
+    }
+  }
+`;
+const ChainButtonContainer = styled.div `
+  position: relative;
+  margin: -8px -8px;
+  &:after {
+    border-radius: var(--border-radius, 0);
+    z-index: 2;
+    content: '';
+    pointer-events: none;
+    position: absolute;
+    inset: 0 2px;
+    box-shadow: inset 0 16px 8px -12px var(--background, var(--ck-body-background)),
+      inset 0 -16px 8px -12px var(--background, var(--ck-body-background));
+  }
+`;
+const ChainButtons = styled(motion.div) `
+  padding: 8px;
+  overflow-x: hidden;
+  overflow-y: auto;
+  max-height: 242px;
+
+  -ms-overflow-style: none; /* Internet Explorer 10+ */
+  scrollbar-width: none; /* Firefox */
+  &::-webkit-scrollbar {
+    display: none; /* Safari and Chrome */
+  }
+
+  @media only screen and (max-width: ${defaultTheme.mobileWidth}px) {
+    padding: 8px 14px;
+    margin: 2px -2px 0;
+    max-height: 60vh;
+  }
+`;
+const ChainButton = styled(motion.button) `
+  appearance: none;
+  cursor: pointer;
+  user-select: none;
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  width: 100%;
+  border-radius: 11px;
+  margin: 0 0 1px;
+  padding: 8px 0;
+  padding-right: 154px;
+  font-size: 15px;
+  line-height: 18px;
+  font-weight: 500;
+  text-decoration: none;
+  color: var(--ck-body-color);
+  background: none;
+  white-space: nowrap;
+  transition: transform 100ms ease, background-color 100ms ease;
+  transform: translateZ(0px);
+  &:before {
+    content: '';
+    background: currentColor;
+    position: absolute;
+    z-index: -1;
+    inset: 0 var(--ck-dropdown-active-inset, -8px);
+    border-radius: var(--ck-dropdown-active-border-radius, 12px);
+    opacity: 0;
+    transition: opacity 180ms ease;
+  }
+  &:after {
+    content: '';
+    position: absolute;
+    z-index: -1;
+    inset: 0 var(--ck-dropdown-active-inset, -8px);
+    border-radius: 12px;
+    opacity: 0;
+    transition: opacity 180ms ease;
+    outline: 2px solid var(--ck-focus-color);
+  }
+  @media only screen and (max-width: ${defaultTheme.mobileWidth}px) {
+    font-size: 17px;
+    padding: 8px 0;
+  }
+  @media only screen and (min-width: ${defaultTheme.mobileWidth}px) {
+    &:hover {
+      &:before {
+        transition-duration: 80ms;
+        opacity: 0.05;
+      }
+    }
+  }
+  &:active {
+    transform: scale(0.99) translateZ(0px);
+  }
+  &:disabled {
+    //opacity: 0.4;
+    pointer-events: none;
+  }
+  &:focus-visible {
+    outline: none !important;
+    &:after {
+      opacity: 1;
+    }
+  }
+  ${(props) => props.$variant === 'secondary' &&
+    css `
+      padding: 12px 4px;
+      margin: 0 0 8px;
+      &:last-child {
+        margin-bottom: 0;
+      }
+      &:before {
+        opacity: 0.05;
+      }
+      &:hover:before {
+        opacity: 0.1;
+      }
+    `}
+`;
+const ChainButtonStatus = styled(motion.div) `
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  right: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+
+  color: var(--ck-body-color-muted);
+  font-size: 15px;
+  line-height: 18px;
+  font-weight: 500;
+  padding-right: 4px;
+  span {
+    display: block;
+    position: relative;
+  }
+  @media only screen and (max-width: ${defaultTheme.mobileWidth}px) {
+    font-size: 17px;
+    padding: 0;
+  }
+`;
+const ChainButtonBg = styled(motion.div) `
+  position: absolute;
+  z-index: -1;
+  inset: 0 var(--ck-dropdown-active-inset, -8px);
+  background: var(--ck-dropdown-active-background, rgba(26, 136, 248, 0.1));
+  box-shadow var(--ck-dropdown-active-box-shadow);
+  border-radius: var(--ck-dropdown-active-border-radius, 12px);
+  
+  @media only screen and (max-width: ${defaultTheme.mobileWidth}px) {
+    inset: 0 var(--ck-dropdown-active-inset, -8px);
+  }
+`;
+
+export { ChainButton, ChainButtonBg, ChainButtonContainer, ChainButtonStatus, ChainButtons, ChainIcon, ChainLogoContainer, ChainLogoSpinner, SwitchNetworksContainer };
+//# sourceMappingURL=styles.js.map

package/build/wagmi/components/ChainSelectList/styles.js.map

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

package/build/wagmi/components/SwitchNetworks/index.js

@@ -0,0 +1,22 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useChainId, useSwitchChain } from 'wagmi';
+import { DisconnectIcon } from '../../../assets/icons.js';
+import Button from '../../../components/Common/Button/index.js';
+import { OrDivider } from '../../../components/Common/Modal/index.js';
+import { ModalContent, ModalBody } from '../../../components/Common/Modal/styles.js';
+import { PageContent } from '../../../components/PageContent/index.js';
+import useLocales from '../../../hooks/useLocales.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import ChainSelectList from '../ChainSelectList/index.js';
+
+const SwitchNetworks = () => {
+    const chainId = useChainId();
+    const { chains } = useSwitchChain();
+    const { logout } = useOpenfortCore();
+    const locales = useLocales({});
+    const chainIsSupported = chainId != null && chains.some((c) => c.id === chainId);
+    return (jsx(PageContent, { width: 278, children: jsxs(ModalContent, { style: { padding: 0, marginTop: -10 }, children: [!chainIsSupported && (jsxs(ModalBody, { children: [locales.warnings_chainUnsupported, " ", locales.warnings_chainUnsupportedResolve] })), jsx("div", { style: { padding: '6px 8px' }, children: jsx(ChainSelectList, { variant: "secondary" }) }), !chainIsSupported && (jsxs("div", { style: { paddingTop: 12 }, children: [jsx(OrDivider, {}), jsx(Button, { icon: jsx(DisconnectIcon, {}), variant: "secondary", onClick: () => logout(), children: locales.disconnect })] }))] }) }));
+};
+
+export { SwitchNetworks as default };
+//# sourceMappingURL=index.js.map

package/build/wagmi/components/SwitchNetworks/index.js.map

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

package/build/wagmi/connectorFilter.d.ts

@@ -0,0 +1,6 @@
+type ConnectorLike = {
+    id: string;
+    name?: string;
+};
+export declare function shouldExcludeConnector(connector: ConnectorLike, allConnectors: ConnectorLike[]): boolean;
+export {};

package/build/wagmi/connectorFilter.js

@@ -0,0 +1,16 @@
+import { embeddedWalletId } from '../constants/openfort.js';
+
+function shouldExcludeConnector(connector, allConnectors) {
+    const { id, name } = connector;
+    const has = (ids) => allConnectors.some((w) => ids.includes(w.id));
+    if (id === embeddedWalletId || (name === null || name === void 0 ? void 0 : name.toLowerCase().includes('openfort')))
+        return true;
+    if (has(['io.metamask', 'io.metamask.mobile']) && (id === 'metaMask' || id === 'metaMaskSDK' || id === 'injected'))
+        return true;
+    if (has(['com.coinbase.wallet']) && id === 'coinbaseWalletSDK')
+        return true;
+    return false;
+}
+
+export { shouldExcludeConnector };
+//# sourceMappingURL=connectorFilter.js.map

package/build/wagmi/connectorFilter.js.map

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

package/build/{defaultConfig.d.ts → wagmi/defaultConfig.d.ts}

@@ -1,6 +1,5 @@
 import type { CreateConfigParameters } from '@wagmi/core';
 import type { CoinbaseWalletParameters } from 'wagmi/connectors';
-export declare const getAppName: () => string;
 type DefaultConfigProps = {
     appName: string;
     appIcon?: string;
@@ -9,5 +8,5 @@ type DefaultConfigProps = {
     walletConnectProjectId?: string;
     coinbaseWalletPreference?: CoinbaseWalletParameters<'4'>['preference'];
 } & Partial<CreateConfigParameters>;
-declare const defaultConfig: ({ appName, appIcon, appDescription, appUrl, walletConnectProjectId, coinbaseWalletPreference, chains, client, ...props }: DefaultConfigProps) => CreateConfigParameters;
+declare const defaultConfig: ({ appName, appIcon, appDescription, appUrl, walletConnectProjectId, coinbaseWalletPreference, chains, ...props }: DefaultConfigProps) => CreateConfigParameters;
 export default defaultConfig;

package/build/wagmi/defaultConfig.js

@@ -0,0 +1,27 @@
+import { http } from 'wagmi';
+import { mainnet, polygon, optimism, arbitrum } from 'wagmi/chains';
+import defaultConnectors from './defaultConnectors.js';
+
+const defaultConfig = ({ appName = 'Openfort', appIcon, appDescription, appUrl, walletConnectProjectId, coinbaseWalletPreference, chains = [mainnet, polygon, optimism, arbitrum], ...props }) => {
+    const { client: _client, transports: _transports, connectors: _connectors, ...rest } = props;
+    const transports = _transports !== null && _transports !== void 0 ? _transports : Object.fromEntries(chains.map((chain) => [chain.id, http()]));
+    const connectors = _connectors !== null && _connectors !== void 0 ? _connectors : defaultConnectors({
+        app: {
+            name: appName,
+            icon: appIcon,
+            description: appDescription,
+            url: appUrl,
+        },
+        walletConnectProjectId,
+        coinbaseWalletPreference,
+    });
+    return {
+        ...rest,
+        chains,
+        connectors,
+        transports,
+    };
+};
+
+export { defaultConfig as default };
+//# sourceMappingURL=defaultConfig.js.map

package/build/wagmi/defaultConfig.js.map

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