@solana/react-hooks 0.0.2 → 0.2.0

package/dist/index.node.cjs

@@ -782,6 +782,191 @@ function SolanaQueryProvider({
   return /* @__PURE__ */ jsxRuntime.jsx(QuerySuspenseContext.Provider, { value: suspense, children: /* @__PURE__ */ jsxRuntime.jsx(useSWR.SWRConfig, { value, children }) });
 }
 __name(SolanaQueryProvider, "SolanaQueryProvider");
+function SolanaProvider({ children, client, config, query, walletPersistence }) {
+  const shouldIncludeQueryLayer = query !== false && query?.disabled !== true;
+  const queryProps = shouldIncludeQueryLayer && query ? query : {};
+  const persistenceConfig = walletPersistence === false ? void 0 : walletPersistence ?? {};
+  const content = shouldIncludeQueryLayer ? /* @__PURE__ */ jsxRuntime.jsx(
+    SolanaQueryProvider,
+    {
+      config: queryProps.config,
+      resetOnClusterChange: queryProps.resetOnClusterChange,
+      suspense: queryProps.suspense,
+      children
+    }
+  ) : children;
+  return /* @__PURE__ */ jsxRuntime.jsxs(SolanaClientProvider, { client, config, children: [
+    persistenceConfig ? /* @__PURE__ */ jsxRuntime.jsx(WalletPersistence, { ...persistenceConfig }) : null,
+    content
+  ] });
+}
+__name(SolanaProvider, "SolanaProvider");
+var DEFAULT_STORAGE_KEY = "solana:last-connector";
+function WalletPersistence({ autoConnect = true, storage, storageKey = DEFAULT_STORAGE_KEY }) {
+  const wallet = useWallet();
+  const connectWallet = useConnectWallet();
+  const client = useSolanaClient();
+  const storageRef = react.useRef(storage ?? getDefaultStorage());
+  const [hasAttemptedAutoConnect, setHasAttemptedAutoConnect] = react.useState(false);
+  const hasPersistedConnectorRef = react.useRef(false);
+  const clientRef = react.useRef(null);
+  react.useEffect(() => {
+    storageRef.current = storage ?? getDefaultStorage();
+  }, [storage]);
+  react.useEffect(() => {
+    if (clientRef.current !== client) {
+      clientRef.current = client;
+      setHasAttemptedAutoConnect(false);
+    }
+  }, [client]);
+  react.useEffect(() => {
+    const activeStorage = storageRef.current;
+    if (!activeStorage) return;
+    if ("connectorId" in wallet && wallet.connectorId) {
+      const connectorId = wallet.connectorId;
+      if (connectorId) {
+        safelyWrite(() => activeStorage.setItem(storageKey, connectorId));
+        hasPersistedConnectorRef.current = true;
+        return;
+      }
+    }
+    if (wallet.status === "disconnected" && hasPersistedConnectorRef.current) {
+      safelyWrite(() => activeStorage.removeItem(storageKey));
+      hasPersistedConnectorRef.current = false;
+    }
+  }, [storageKey, wallet]);
+  react.useEffect(() => {
+    if (!autoConnect || hasAttemptedAutoConnect) {
+      return;
+    }
+    if (wallet.status === "connected" || wallet.status === "connecting") {
+      setHasAttemptedAutoConnect(true);
+      return;
+    }
+    const activeStorage = storageRef.current;
+    if (!activeStorage) {
+      setHasAttemptedAutoConnect(true);
+      return;
+    }
+    let cancelled = false;
+    const connectorId = safelyRead(() => activeStorage.getItem(storageKey));
+    if (!connectorId) {
+      setHasAttemptedAutoConnect(true);
+      return;
+    }
+    const connector = client.connectors.get(connectorId);
+    if (!connector) {
+      return;
+    }
+    void (async () => {
+      try {
+        await connectWallet(connectorId, { autoConnect: true });
+      } catch {
+      } finally {
+        if (!cancelled) {
+          setHasAttemptedAutoConnect(true);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [autoConnect, client, connectWallet, hasAttemptedAutoConnect, storageKey, wallet.status]);
+  return null;
+}
+__name(WalletPersistence, "WalletPersistence");
+function safelyRead(reader) {
+  try {
+    return reader();
+  } catch {
+    return null;
+  }
+}
+__name(safelyRead, "safelyRead");
+function safelyWrite(writer) {
+  try {
+    writer();
+  } catch {
+  }
+}
+__name(safelyWrite, "safelyWrite");
+function getDefaultStorage() {
+  if (typeof globalThis !== "object" || globalThis === null) {
+    return null;
+  }
+  const candidate = globalThis.localStorage;
+  if (!candidate) {
+    return null;
+  }
+  return candidate;
+}
+__name(getDefaultStorage, "getDefaultStorage");
+function useWalletConnection(options = {}) {
+  const wallet = useWallet();
+  const connectWallet = useConnectWallet();
+  const disconnectWallet = useDisconnectWallet();
+  const discovered = useWalletStandardConnectors(options.discoveryOptions);
+  const connectors = options.connectors ?? discovered;
+  const connect = react.useCallback(
+    (connectorId, connectOptions) => connectWallet(connectorId, connectOptions),
+    [connectWallet]
+  );
+  const disconnect = react.useCallback(() => disconnectWallet(), [disconnectWallet]);
+  const state = react.useMemo(() => {
+    const connectorId = "connectorId" in wallet ? wallet.connectorId : void 0;
+    const session = wallet.status === "connected" ? wallet.session : void 0;
+    const error = wallet.status === "error" ? wallet.error ?? null : null;
+    return {
+      connect,
+      connected: wallet.status === "connected",
+      connecting: wallet.status === "connecting",
+      connectors,
+      connectorId,
+      disconnect,
+      error,
+      status: wallet.status,
+      wallet: session
+    };
+  }, [connect, connectors, disconnect, wallet]);
+  return state;
+}
+__name(useWalletConnection, "useWalletConnection");
+function WalletConnectionManager({ children, connectors, discoveryOptions }) {
+  const state = useWalletConnection({ connectors, discoveryOptions });
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: children(state) });
+}
+__name(WalletConnectionManager, "WalletConnectionManager");
+function useWalletModalState(options = {}) {
+  const connection = useWalletConnection(options);
+  const [isOpen, setIsOpen] = react.useState(options.initialOpen ?? false);
+  const [selectedConnector, setSelectedConnector] = react.useState(null);
+  const closeOnConnect = options.closeOnConnect ?? true;
+  const open = react.useCallback(() => setIsOpen(true), []);
+  const close = react.useCallback(() => setIsOpen(false), []);
+  const toggle = react.useCallback(() => setIsOpen((value) => !value), []);
+  const select = react.useCallback((connectorId) => setSelectedConnector(connectorId), []);
+  const connect = react.useCallback(
+    async (connectorId, connectOptions) => {
+      await connection.connect(connectorId, connectOptions);
+      setSelectedConnector(connectorId);
+      if (closeOnConnect) {
+        setIsOpen(false);
+      }
+    },
+    [closeOnConnect, connection]
+  );
+  return {
+    ...connection,
+    close,
+    connect,
+    isOpen,
+    open,
+    selectedConnector,
+    select,
+    toggle
+  };
+}
+__name(useWalletModalState, "useWalletModalState");
 function useSignAndSendTransaction(uiWalletAccount, chain) {
   const signAndSendTransactions = useSignAndSendTransactions(uiWalletAccount, chain);
   return react.useCallback(
@@ -1111,7 +1296,9 @@ function useWalletAccountTransactionSendingSigner(uiWalletAccount, chain) {
 __name(useWalletAccountTransactionSendingSigner, "useWalletAccountTransactionSendingSigner");
 
 exports.SolanaClientProvider = SolanaClientProvider;
+exports.SolanaProvider = SolanaProvider;
 exports.SolanaQueryProvider = SolanaQueryProvider;
+exports.WalletConnectionManager = WalletConnectionManager;
 exports.useAccount = useAccount;
 exports.useBalance = useBalance;
 exports.useClientStore = useClientStore;
@@ -1138,6 +1325,8 @@ exports.useWalletAccountMessageSigner = useWalletAccountMessageSigner;
 exports.useWalletAccountTransactionSendingSigner = useWalletAccountTransactionSendingSigner;
 exports.useWalletAccountTransactionSigner = useWalletAccountTransactionSigner;
 exports.useWalletActions = useWalletActions;
+exports.useWalletConnection = useWalletConnection;
+exports.useWalletModalState = useWalletModalState;
 exports.useWalletSession = useWalletSession;
 exports.useWalletStandardConnectors = useWalletStandardConnectors;
 //# sourceMappingURL=index.node.cjs.map