@particle-network/connectkit/dist/esm/chunk-UXLD5X4D.mjs

"use client";
import {
  init_useLastConnectorId,
  useLastConnectorId
} from "./chunk-XV4TVGGP.mjs";
import {
  init_context,
  init_useMutation,
  useContext,
  useMutation
} from "./chunk-4TIAGANX.mjs";
import {
  __esm
} from "./chunk-Y7A564BU.mjs";

// src/actions/connect.ts
import {
  ConnectorAlreadyConnectedError
} from "@particle-network/connector-core";
async function connect(config, parameters) {
  const connector = parameters.connector;
  if (connector.uid === config.state.current)
    throw new ConnectorAlreadyConnectedError();
  try {
    config.setState((x) => ({ ...x, status: "connecting" }));
    connector.emitter.emit("message", { type: "connecting" });
    const data = await connector.connect({
      chainId: parameters.chainId,
      ...parameters.authParams,
      ...parameters.passkeyParams
    });
    const accounts = data.accounts;
    connector.emitter.off("connect", config._internal.events.connect);
    connector.emitter.on("change", config._internal.events.change);
    connector.emitter.on("disconnect", config._internal.events.disconnect);
    await config.storage?.setItem("recentConnectorId", connector.id);
    config.setState((x) => ({
      ...x,
      connections: new Map(x.connections).set(connector.uid, {
        accounts,
        chainId: data.chainId,
        connector
      }),
      current: connector.uid,
      status: "connected"
    }));
    return { accounts, chainId: data.chainId };
  } catch (error) {
    config.setState((x) => ({
      ...x,
      status: x.current ? "connected" : "disconnected"
    }));
    throw error;
  }
}
var init_connect = __esm({
  "src/actions/connect.ts"() {
    "use strict";
  }
});

// src/hooks/useConnect.ts
import { isEVMChain, isSolanaChain } from "@particle-network/connector-core";
function useConnect(parameters) {
  const { config, options } = useContext();
  const { updateLastConnectorId } = useLastConnectorId();
  const mutationFn = async (parameters2) => {
    const { connector, chainId } = parameters2;
    let connectChainId = chainId;
    if (!connectChainId) {
      if (connector.chainType === "evm") {
        connectChainId = options.initialChainId?.evm;
        if (!connectChainId) {
          connectChainId = config.chains.find(isEVMChain)?.id;
        }
      } else {
        connectChainId = options.initialChainId?.solana;
        if (!connectChainId) {
          connectChainId = config.chains.find(isSolanaChain)?.id;
        }
      }
    }
    const result = await connect(config, {
      ...parameters2,
      chainId: connectChainId
    });
    if (connector.id !== "walletConnect") {
      updateLastConnectorId(connector.id);
    }
    return result;
  };
  const { status, data, error, mutate, mutateAsync } = useMutation(mutationFn, parameters);
  return {
    status,
    data,
    error,
    connect: mutate,
    connectAsync: mutateAsync
  };
}
var init_useConnect = __esm({
  "src/hooks/useConnect.ts"() {
    "use strict";
    init_connect();
    init_context();
    init_useLastConnectorId();
    init_useMutation();
  }
});

export {
  useConnect,
  init_useConnect
};
//# sourceMappingURL=chunk-UXLD5X4D.mjs.map