@vue-solana/vue 0.2.1 → 0.2.3

package/dist/index.d.ts

@@ -1,78 +1,15 @@
-import * as vue from 'vue';
-import { MaybeRefOrGetter, Ref, InjectionKey, App } from 'vue';
-import { PublicKey, Commitment, TransactionSignature } from '@solana/web3-compat';
-import * as _vue_solana_core from '@vue-solana/core';
-import { SendTransactionOptions, SolanaContext, SolanaWallet, SolanaWalletInfo, SolanaConfig } from '@vue-solana/core';
-
-declare function useBalance(address: MaybeRefOrGetter<PublicKey | string | null | undefined>, commitment?: Commitment): {
-    balance: vue.Ref<number | null, number | null>;
-    loading: vue.Ref<boolean, boolean>;
-    error: vue.Ref<unknown, unknown>;
-    refresh: () => Promise<number | null>;
-};
-
-declare function useConnection(): Connection;
-
-declare function useRpc(): {
-    cluster: vue.ComputedRef<_vue_solana_core.SolanaCluster>;
-    endpoint: vue.ComputedRef<string>;
-    wsEndpoint: vue.ComputedRef<string>;
-    status: vue.Ref<SolanaConnectionStatus, SolanaConnectionStatus>;
-    error: vue.Ref<string | null, string | null>;
-    latestBlockhash: vue.Ref<string | null, string | null>;
-    checkConnection: () => Promise<void>;
-    connection: Connection;
-};
-
-declare function useSignAndSendTransaction(): {
-    signature: any;
-    loading: vue.Ref<boolean, boolean>;
-    error: vue.Ref<unknown, unknown>;
-    execute: (transaction: any, options?: SendTransactionOptions | undefined) => Promise<any>;
-};
-
-declare function useSolana(): VueSolanaContext;
-
-declare function useTransaction<TArgs extends unknown[]>(handler: (...args: TArgs) => Promise<TransactionSignature>): {
-    signature: any;
-    loading: vue.Ref<boolean, boolean>;
-    error: vue.Ref<unknown, unknown>;
-    execute: (...args: TArgs) => Promise<any>;
-};
-
-declare function useWallet(): {
-    wallet: vue.Ref<_vue_solana_core.SolanaWallet | null, _vue_solana_core.SolanaWallet | null>;
-    publicKey: vue.ComputedRef<any>;
-    connected: vue.ComputedRef<boolean>;
-    connecting: vue.ComputedRef<boolean>;
-    disconnecting: vue.ComputedRef<boolean>;
-    loading: vue.ComputedRef<boolean>;
-    setWallet: (wallet: _vue_solana_core.SolanaWallet | null) => void;
-    connect: () => Promise<void>;
-    disconnect: () => Promise<void>;
-};
-
-declare function useWallets(): {
-    wallets: vue.Ref<_vue_solana_core.SolanaWalletInfo[], _vue_solana_core.SolanaWalletInfo[]>;
-    selectedWallet: vue.Ref<_vue_solana_core.SolanaWalletInfo | null, _vue_solana_core.SolanaWalletInfo | null>;
-    refreshWallets: () => void;
-    selectWallet: (wallet: _vue_solana_core.SolanaWalletInfo | null) => void;
-};
-
-type SolanaConnectionStatus = "idle" | "checking" | "connected" | "error";
-interface VueSolanaContext extends SolanaContext {
-    wallet: Ref<SolanaWallet | null>;
-    status: Ref<SolanaConnectionStatus>;
-    error: Ref<string | null>;
-    latestBlockhash: Ref<string | null>;
-    wallets: Ref<SolanaWalletInfo[]>;
-    selectedWallet: Ref<SolanaWalletInfo | null>;
-    checkConnection: () => Promise<void>;
-    setWallet: (wallet: SolanaWallet | null) => void;
-    refreshWallets: () => void;
-    selectWallet: (wallet: SolanaWalletInfo | null) => void;
-}
-declare const solanaInjectionKey: InjectionKey<VueSolanaContext>;
+export { useBalance } from './useBalance.js';
+export { useConnection } from './useConnection.js';
+export { useRpc } from './useRpc.js';
+export { useSignAndSendTransaction } from './useSignAndSendTransaction.js';
+export { tryUseSolana, useSolana } from './useSolana.js';
+export { useTransaction } from './useTransaction.js';
+export { useWallet } from './useWallet.js';
+export { useWallets } from './useWallets.js';
+export { S as SolanaConnectionStatus, V as VueSolanaContext, s as solanaInjectionKey } from './shared/vue.DGhodYJh.js';
+import { SolanaConfig, SolanaWallet } from '@vue-solana/core/types';
+import { App } from 'vue';
+import '@solana/web3-compat';
 
 interface VueSolanaPluginOptions extends SolanaConfig {
     wallet?: SolanaWallet | null;
@@ -82,5 +19,5 @@ declare function createSolanaPlugin(options?: VueSolanaPluginOptions): {
 };
 declare const VueSolana: typeof createSolanaPlugin;
 
-export { VueSolana, createSolanaPlugin, solanaInjectionKey, useBalance, useConnection, useRpc, useSignAndSendTransaction, useSolana, useTransaction, useWallet, useWallets };
-export type { SolanaConnectionStatus, VueSolanaContext, VueSolanaPluginOptions };
+export { VueSolana, createSolanaPlugin };
+export type { VueSolanaPluginOptions };

package/dist/index.mjs

@@ -1,182 +1,16 @@
-import { PublicKey } from '@solana/web3-compat';
-import { inject, computed, ref, watch, toValue, triggerRef, shallowRef } from 'vue';
-import { signAndSendTransaction, createSolanaContext, adaptSolanaStandardWallet, getSolanaChain, subscribeSolanaWallets, getRegisteredSolanaWallets } from '@vue-solana/core';
-
-const solanaInjectionKey = Symbol("VueSolana");
-
-function useSolana() {
-  const context = inject(solanaInjectionKey);
-  if (!context) {
-    throw new Error("Vue Solana plugin is not installed");
-  }
-  return context;
-}
-
-function useRpc() {
-  const solana = useSolana();
-  return {
-    cluster: computed(() => solana.cluster),
-    endpoint: computed(() => solana.endpoint),
-    wsEndpoint: computed(() => solana.wsEndpoint),
-    status: solana.status,
-    error: solana.error,
-    latestBlockhash: solana.latestBlockhash,
-    checkConnection: solana.checkConnection,
-    connection: solana.connection
-  };
-}
-
-function useConnection() {
-  return useRpc().connection;
-}
-
-function useBalance(address, commitment) {
-  const connection = useConnection();
-  const balance = ref(null);
-  const loading = ref(false);
-  const error = ref(null);
-  async function refresh() {
-    const value = toValue(address);
-    if (!value) {
-      balance.value = null;
-      return null;
-    }
-    loading.value = true;
-    error.value = null;
-    try {
-      const publicKey = typeof value === "string" ? new PublicKey(value) : value;
-      balance.value = await connection.getBalance(publicKey, commitment);
-      return balance.value;
-    } catch (cause) {
-      error.value = cause;
-      throw cause;
-    } finally {
-      loading.value = false;
-    }
-  }
-  watch(
-    () => toValue(address),
-    () => {
-      void refresh().catch(() => void 0);
-    },
-    { immediate: true }
-  );
-  return {
-    balance,
-    loading,
-    error,
-    refresh
-  };
-}
-
-function useWallet() {
-  const solana = useSolana();
-  const wallet = solana.wallet;
-  const connecting = ref(false);
-  const disconnecting = ref(false);
-  async function connect() {
-    const activeWallet = wallet.value;
-    if (!activeWallet) {
-      throw new Error("No Solana wallet is configured");
-    }
-    connecting.value = true;
-    try {
-      const connection = activeWallet.connect();
-      triggerRef(wallet);
-      await connection;
-      triggerRef(wallet);
-      console.info("[Vue Solana] Wallet connected", {
-        publicKey: activeWallet.publicKey?.toBase58() ?? null
-      });
-    } catch (error) {
-      triggerRef(wallet);
-      console.error("[Vue Solana] Wallet connection failed", error);
-      throw error;
-    } finally {
-      connecting.value = false;
-    }
-  }
-  async function disconnect() {
-    const activeWallet = wallet.value;
-    if (!activeWallet) {
-      return;
-    }
-    const publicKey = activeWallet.publicKey?.toBase58() ?? null;
-    disconnecting.value = true;
-    try {
-      await activeWallet.disconnect();
-      triggerRef(wallet);
-      console.info("[Vue Solana] Wallet disconnected", { publicKey });
-    } catch (error) {
-      triggerRef(wallet);
-      console.error("[Vue Solana] Wallet disconnection failed", error);
-      throw error;
-    } finally {
-      disconnecting.value = false;
-    }
-  }
-  const isConnecting = computed(() => Boolean(connecting.value || wallet.value?.connecting));
-  const isDisconnecting = computed(
-    () => Boolean(disconnecting.value || wallet.value?.disconnecting)
-  );
-  return {
-    wallet,
-    publicKey: computed(() => wallet.value?.publicKey ?? null),
-    connected: computed(() => Boolean(wallet.value?.connected && wallet.value.publicKey)),
-    connecting: isConnecting,
-    disconnecting: isDisconnecting,
-    loading: computed(() => isConnecting.value || isDisconnecting.value),
-    setWallet: solana.setWallet,
-    connect,
-    disconnect
-  };
-}
-
-function useTransaction(handler) {
-  const signature = ref(null);
-  const loading = ref(false);
-  const error = ref(null);
-  async function execute(...args) {
-    loading.value = true;
-    error.value = null;
-    try {
-      signature.value = await handler(...args);
-      return signature.value;
-    } catch (cause) {
-      error.value = cause;
-      throw cause;
-    } finally {
-      loading.value = false;
-    }
-  }
-  return {
-    signature,
-    loading,
-    error,
-    execute
-  };
-}
-
-function useSignAndSendTransaction() {
-  const connection = useConnection();
-  const { wallet } = useWallet();
-  return useTransaction((transaction, options) => {
-    if (!wallet.value) {
-      return Promise.reject(new Error("No Solana wallet is configured"));
-    }
-    return signAndSendTransaction(connection, wallet.value, transaction, options);
-  });
-}
-
-function useWallets() {
-  const solana = useSolana();
-  return {
-    wallets: solana.wallets,
-    selectedWallet: solana.selectedWallet,
-    refreshWallets: solana.refreshWallets,
-    selectWallet: solana.selectWallet
-  };
-}
+export { u as useBalance } from './shared/vue.D81obqiN.mjs';
+export { u as useConnection } from './shared/vue.DlEAL2G8.mjs';
+export { u as useRpc } from './shared/vue.BqDzSepb.mjs';
+export { u as useSignAndSendTransaction } from './shared/vue.PoQ8Vpmy.mjs';
+import { s as solanaInjectionKey } from './shared/vue.1M_c5FWA.mjs';
+export { t as tryUseSolana, u as useSolana } from './shared/vue.1M_c5FWA.mjs';
+export { u as useTransaction } from './shared/vue.BMUEDN2t.mjs';
+export { u as useWallet } from './shared/vue.DYf_CRDv.mjs';
+export { u as useWallets } from './shared/vue.h-uS8MXN.mjs';
+import { subscribeSolanaWallets, getRegisteredSolanaWallets, adaptSolanaStandardWallet, getSolanaChain } from '@vue-solana/core/wallet-standard';
+import { createSolanaContext } from '@vue-solana/core/rpc';
+import { shallowRef, ref, triggerRef } from 'vue';
+import '@vue-solana/core/transaction';
 
 const RPC_CHECK_TIMEOUT_MS = 1e4;
 function createSolanaPlugin(options = {}) {
@@ -189,6 +23,7 @@ function createSolanaPlugin(options = {}) {
       const status = ref("idle");
       const error = ref(null);
       const latestBlockhash = ref(null);
+      const adaptedWallets = /* @__PURE__ */ new WeakMap();
       let unsubscribeWallets = null;
       let rpcCheckId = 0;
       async function checkConnection() {
@@ -238,10 +73,61 @@ function createSolanaPlugin(options = {}) {
       }
       function selectWallet(nextWallet) {
         selectedWallet.value = nextWallet;
-        wallet.value = nextWallet ? adaptSolanaStandardWallet(nextWallet, {
+        wallet.value = nextWallet ? getAdaptedWallet(nextWallet) : options.wallet ?? null;
+      }
+      function getAdaptedWallet(walletInfo) {
+        if (!isObject(walletInfo.wallet)) {
+          return adaptSolanaStandardWallet(walletInfo, {
+            chain: getSolanaChain(context.cluster),
+            onChange: () => triggerRef(wallet)
+          });
+        }
+        const cachedWallet = adaptedWallets.get(walletInfo.wallet);
+        if (cachedWallet) {
+          return cachedWallet;
+        }
+        const adaptedWallet = adaptSolanaStandardWallet(walletInfo, {
           chain: getSolanaChain(context.cluster),
           onChange: () => triggerRef(wallet)
-        }) : options.wallet ?? null;
+        });
+        const cachedAdapter = {
+          get publicKey() {
+            return adaptedWallet.publicKey;
+          },
+          get connected() {
+            return adaptedWallet.connected;
+          },
+          get connecting() {
+            return adaptedWallet.connecting;
+          },
+          get disconnecting() {
+            return adaptedWallet.disconnecting;
+          },
+          async connect() {
+            await adaptedWallet.connect();
+            await Promise.all(
+              Array.from(getCachedWallets()).map(
+                (otherWallet) => otherWallet !== cachedAdapter && otherWallet.connected ? otherWallet.disconnect() : void 0
+              )
+            );
+          },
+          disconnect: () => adaptedWallet.disconnect(),
+          signTransaction: adaptedWallet.signTransaction?.bind(adaptedWallet),
+          signAllTransactions: adaptedWallet.signAllTransactions?.bind(adaptedWallet),
+          signAndSendTransaction: adaptedWallet.signAndSendTransaction?.bind(adaptedWallet)
+        };
+        adaptedWallets.set(walletInfo.wallet, cachedAdapter);
+        return cachedAdapter;
+      }
+      function* getCachedWallets() {
+        for (const walletInfo of wallets.value) {
+          if (isObject(walletInfo.wallet)) {
+            const cachedWallet = adaptedWallets.get(walletInfo.wallet);
+            if (cachedWallet) {
+              yield cachedWallet;
+            }
+          }
+        }
       }
       const vueContext = {
         ...context,
@@ -260,10 +146,15 @@ function createSolanaPlugin(options = {}) {
         }
       };
       app.provide(solanaInjectionKey, vueContext);
-      void checkConnection();
+      if (typeof window !== "undefined") {
+        void checkConnection();
+      }
     }
   };
 }
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
 const VueSolana = createSolanaPlugin;
 function withTimeout(promise, timeoutMs, message) {
   let timeoutId;
@@ -279,4 +170,4 @@ function withTimeout(promise, timeoutMs, message) {
   });
 }
 
-export { VueSolana, createSolanaPlugin, solanaInjectionKey, useBalance, useConnection, useRpc, useSignAndSendTransaction, useSolana, useTransaction, useWallet, useWallets };
+export { VueSolana, createSolanaPlugin, solanaInjectionKey };

package/dist/shared/vue.1M_c5FWA.mjs

@@ -0,0 +1,46 @@
+import { inject, shallowRef, ref } from 'vue';
+
+const solanaInjectionKey = Symbol("VueSolana");
+
+let ssrContext;
+function tryUseSolana() {
+  return inject(solanaInjectionKey, null);
+}
+function useSolana() {
+  return tryUseSolana() ?? getSsrContext();
+}
+function getSsrContext() {
+  ssrContext ??= {
+    cluster: "devnet",
+    endpoint: "",
+    wsEndpoint: "",
+    connection: createUnavailableConnection(),
+    wallet: shallowRef(null),
+    status: ref("idle"),
+    error: ref(null),
+    latestBlockhash: ref(null),
+    wallets: shallowRef([]),
+    selectedWallet: shallowRef(null),
+    async checkConnection() {
+    },
+    setWallet() {
+    },
+    refreshWallets() {
+    },
+    selectWallet() {
+    }
+  };
+  return ssrContext;
+}
+function createUnavailableConnection() {
+  return new Proxy(
+    {},
+    {
+      get() {
+        throw new Error("Vue Solana plugin is not installed");
+      }
+    }
+  );
+}
+
+export { solanaInjectionKey as s, tryUseSolana as t, useSolana as u };

package/dist/shared/vue.BMUEDN2t.mjs

@@ -0,0 +1,28 @@
+import { ref } from 'vue';
+
+function useTransaction(handler) {
+  const signature = ref(null);
+  const loading = ref(false);
+  const error = ref(null);
+  async function execute(...args) {
+    loading.value = true;
+    error.value = null;
+    try {
+      signature.value = await handler(...args);
+      return signature.value;
+    } catch (cause) {
+      error.value = cause;
+      throw cause;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    signature,
+    loading,
+    error,
+    execute
+  };
+}
+
+export { useTransaction as u };

package/dist/shared/vue.BSVxQ9Yi.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const vue = require('vue');
+
+function useTransaction(handler) {
+  const signature = vue.ref(null);
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  async function execute(...args) {
+    loading.value = true;
+    error.value = null;
+    try {
+      signature.value = await handler(...args);
+      return signature.value;
+    } catch (cause) {
+      error.value = cause;
+      throw cause;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    signature,
+    loading,
+    error,
+    execute
+  };
+}
+
+exports.useTransaction = useTransaction;

package/dist/shared/vue.BqDzSepb.mjs

@@ -0,0 +1,18 @@
+import { computed } from 'vue';
+import { u as useSolana } from './vue.1M_c5FWA.mjs';
+
+function useRpc() {
+  const solana = useSolana();
+  return {
+    cluster: computed(() => solana.cluster),
+    endpoint: computed(() => solana.endpoint),
+    wsEndpoint: computed(() => solana.wsEndpoint),
+    status: solana.status,
+    error: solana.error,
+    latestBlockhash: solana.latestBlockhash,
+    checkConnection: solana.checkConnection,
+    connection: solana.connection
+  };
+}
+
+export { useRpc as u };

package/dist/shared/vue.C4tLiG3R.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+const vue = require('vue');
+
+const solanaInjectionKey = Symbol("VueSolana");
+
+let ssrContext;
+function tryUseSolana() {
+  return vue.inject(solanaInjectionKey, null);
+}
+function useSolana() {
+  return tryUseSolana() ?? getSsrContext();
+}
+function getSsrContext() {
+  ssrContext ??= {
+    cluster: "devnet",
+    endpoint: "",
+    wsEndpoint: "",
+    connection: createUnavailableConnection(),
+    wallet: vue.shallowRef(null),
+    status: vue.ref("idle"),
+    error: vue.ref(null),
+    latestBlockhash: vue.ref(null),
+    wallets: vue.shallowRef([]),
+    selectedWallet: vue.shallowRef(null),
+    async checkConnection() {
+    },
+    setWallet() {
+    },
+    refreshWallets() {
+    },
+    selectWallet() {
+    }
+  };
+  return ssrContext;
+}
+function createUnavailableConnection() {
+  return new Proxy(
+    {},
+    {
+      get() {
+        throw new Error("Vue Solana plugin is not installed");
+      }
+    }
+  );
+}
+
+exports.solanaInjectionKey = solanaInjectionKey;
+exports.tryUseSolana = tryUseSolana;
+exports.useSolana = useSolana;

package/dist/shared/vue.COyyrsQU.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const vue = require('vue');
+const useSolana = require('./vue.C4tLiG3R.cjs');
+
+function useRpc() {
+  const solana = useSolana.useSolana();
+  return {
+    cluster: vue.computed(() => solana.cluster),
+    endpoint: vue.computed(() => solana.endpoint),
+    wsEndpoint: vue.computed(() => solana.wsEndpoint),
+    status: solana.status,
+    error: solana.error,
+    latestBlockhash: solana.latestBlockhash,
+    checkConnection: solana.checkConnection,
+    connection: solana.connection
+  };
+}
+
+exports.useRpc = useRpc;

package/dist/shared/vue.CTM6XQ47.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+const transaction = require('@vue-solana/core/transaction');
+const useConnection = require('./vue.CwhEmATP.cjs');
+const useWallet = require('./vue.CwPjPFN6.cjs');
+const useTransaction = require('./vue.BSVxQ9Yi.cjs');
+
+function useSignAndSendTransaction() {
+  const connection = useConnection.useConnection();
+  const { wallet } = useWallet.useWallet();
+  return useTransaction.useTransaction((transaction$1, options) => {
+    if (!wallet.value) {
+      return Promise.reject(new Error("No Solana wallet is configured"));
+    }
+    return transaction.signAndSendTransaction(connection, wallet.value, transaction$1, options);
+  });
+}
+
+exports.useSignAndSendTransaction = useSignAndSendTransaction;

package/dist/shared/vue.CjKm-Cw1.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const vue = require('vue');
+const useConnection = require('./vue.CwhEmATP.cjs');
+const useSolana = require('./vue.C4tLiG3R.cjs');
+
+function useBalance(address, commitment) {
+  const solana = useSolana.tryUseSolana();
+  const connection = solana?.connection ?? useConnection.useConnection();
+  const balance = vue.ref(null);
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  async function refresh() {
+    const value = vue.toValue(address);
+    if (!value || !solana) {
+      balance.value = null;
+      return null;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const publicKey = typeof value === "string" ? new (await import('@solana/web3-compat')).PublicKey(value) : value;
+      balance.value = await connection.getBalance(publicKey, commitment);
+      return balance.value;
+    } catch (cause) {
+      error.value = cause;
+      throw cause;
+    } finally {
+      loading.value = false;
+    }
+  }
+  vue.watch(
+    () => vue.toValue(address),
+    () => {
+      void refresh().catch(() => void 0);
+    },
+    { immediate: true }
+  );
+  return {
+    balance,
+    loading,
+    error,
+    refresh
+  };
+}
+
+exports.useBalance = useBalance;