@vue-solana/vue 2.6.1 → 3.0.1

package/dist/shared/vue.DKyQ7J67.cjs

@@ -1,15 +0,0 @@
-'use strict';
-
-const useSolana = require('./vue.DE3emjSF.cjs');
-
-function useWallets() {
-  const solana = useSolana.useSolana();
-  return {
-    wallets: solana.wallets,
-    selectedWallet: solana.selectedWallet,
-    refreshWallets: solana.refreshWallets,
-    selectWallet: solana.selectWallet
-  };
-}
-
-exports.useWallets = useWallets;

package/dist/shared/vue.DL3z5PxP.d.cts

@@ -1,21 +0,0 @@
-import { SolanaError } from '@vue-solana/core/errors';
-import { SolanaContext, SolanaWallet, SolanaWalletInfo } from '@vue-solana/core/types';
-import { Ref, InjectionKey } from 'vue';
-
-type SolanaConnectionStatus = "idle" | "checking" | "connected" | "error";
-interface VueSolanaContext extends SolanaContext {
-    wallet: Ref<SolanaWallet | null>;
-    status: Ref<SolanaConnectionStatus>;
-    error: Ref<SolanaError | 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 { solanaInjectionKey as s };
-export type { SolanaConnectionStatus as S, VueSolanaContext as V };

package/dist/shared/vue.DNxOpDXz.cjs

@@ -1,12 +0,0 @@
-'use strict';
-
-function decodeBase64(value) {
-  const binary = atob(value);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index += 1) {
-    bytes[index] = binary.charCodeAt(index);
-  }
-  return bytes;
-}
-
-exports.decodeBase64 = decodeBase64;

package/dist/shared/vue.Di7yjJ-R.cjs

@@ -1,87 +0,0 @@
-'use strict';
-
-const errors = require('@vue-solana/core/errors');
-const vue = require('vue');
-const address = require('@vue-solana/core/address');
-const useConnection = require('./vue.BVaMoz9y.cjs');
-const useSolana = require('./vue.DE3emjSF.cjs');
-const decodeBase64 = require('./vue.DNxOpDXz.cjs');
-
-function useProgramAccounts(programId, options = {}) {
-  const solana = useSolana.tryUseSolana();
-  const client = solana?.client ?? useConnection.useConnection();
-  const accounts = vue.shallowRef([]);
-  const loading = vue.shallowRef(false);
-  const error = vue.shallowRef(null);
-  let refreshId = 0;
-  async function refresh() {
-    const requestId = ++refreshId;
-    const value = vue.toValue(programId);
-    if (!value || !solana) {
-      accounts.value = [];
-      loading.value = false;
-      error.value = null;
-      return [];
-    }
-    loading.value = true;
-    error.value = null;
-    try {
-      const parsedAddress = address.parseAddress(value);
-      if (!parsedAddress) {
-        accounts.value = [];
-        return [];
-      }
-      const { value: response } = await client.rpc.getProgramAccounts(parsedAddress, {
-        encoding: "base64",
-        commitment: options.commitment,
-        dataSlice: options.dataSlice,
-        filters: options.filters
-      }).send();
-      const nextAccounts = response.map(({ pubkey, account }) => ({
-        pubkey,
-        account: {
-          executable: account.executable,
-          lamports: Number(account.lamports),
-          owner: account.owner,
-          space: Number(account.space),
-          data: decodeBase64.decodeBase64(account.data[0])
-        }
-      }));
-      if (requestId === refreshId) {
-        accounts.value = nextAccounts;
-      }
-      return nextAccounts;
-    } catch (cause) {
-      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
-      if (requestId === refreshId) {
-        accounts.value = [];
-        error.value = normalizedError;
-      }
-      throw normalizedError;
-    } finally {
-      if (requestId === refreshId) {
-        loading.value = false;
-      }
-    }
-  }
-  vue.onMounted(() => {
-    void refresh().catch(() => void 0);
-  });
-  vue.onUnmounted(() => {
-    refreshId += 1;
-  });
-  vue.watch(
-    () => vue.toValue(programId),
-    () => {
-      void refresh().catch(() => void 0);
-    }
-  );
-  return {
-    accounts,
-    loading,
-    error,
-    refresh
-  };
-}
-
-exports.useProgramAccounts = useProgramAccounts;

package/dist/shared/vue.Dn3KLJZH.cjs

@@ -1,121 +0,0 @@
-'use strict';
-
-const errors = require('@vue-solana/core/errors');
-const vue = require('vue');
-const useClientCapability = require('./vue.4C5kX4fE.cjs');
-const useSolanaClient = require('./vue.BIxphCAq.cjs');
-
-const PLANNING_PROVIDER_HINT = "Install a planner plugin, e.g. `createClient().use(rpcTransactionPlanner())` from `@solana/kit-plugin-rpc`, and plan with a client that has a `payer` signer \u2014 Kit reads `client.payer` to set the fee payer.";
-function usePlanTransaction() {
-  useClientCapability.useClientCapability(["planTransaction", "payer"], {
-    hookName: "usePlanTransaction",
-    providerHint: PLANNING_PROVIDER_HINT
-  });
-  const { client } = useSolanaClient.useSolanaClient();
-  const transactionMessage = vue.shallowRef(null);
-  const status = vue.ref("idle");
-  const loading = vue.ref(false);
-  const error = vue.ref(null);
-  let executionId = 0;
-  let abortController;
-  vue.onScopeDispose(() => {
-    abortController?.abort();
-    executionId++;
-  });
-  async function execute(input, config) {
-    abortController?.abort();
-    const controller = new AbortController();
-    abortController = controller;
-    const currentExecutionId = ++executionId;
-    const planner = client;
-    status.value = "planning";
-    loading.value = true;
-    error.value = null;
-    transactionMessage.value = null;
-    try {
-      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
-      const message = await planner.planTransaction(input, { abortSignal });
-      if (currentExecutionId === executionId) {
-        transactionMessage.value = message;
-        status.value = "planned";
-      }
-      return message;
-    } catch (cause) {
-      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
-      if (currentExecutionId === executionId) {
-        error.value = normalizedError;
-        status.value = "error";
-      }
-      throw normalizedError;
-    } finally {
-      if (currentExecutionId === executionId) {
-        loading.value = false;
-      }
-    }
-  }
-  return {
-    transactionMessage,
-    status,
-    loading,
-    error,
-    execute
-  };
-}
-function usePlanTransactions() {
-  useClientCapability.useClientCapability(["planTransactions", "payer"], {
-    hookName: "usePlanTransactions",
-    providerHint: PLANNING_PROVIDER_HINT
-  });
-  const { client } = useSolanaClient.useSolanaClient();
-  const transactionPlan = vue.shallowRef(null);
-  const status = vue.ref("idle");
-  const loading = vue.ref(false);
-  const error = vue.ref(null);
-  let executionId = 0;
-  let abortController;
-  vue.onScopeDispose(() => {
-    abortController?.abort();
-    executionId++;
-  });
-  async function execute(input, config) {
-    abortController?.abort();
-    const controller = new AbortController();
-    abortController = controller;
-    const currentExecutionId = ++executionId;
-    const planner = client;
-    status.value = "planning";
-    loading.value = true;
-    error.value = null;
-    transactionPlan.value = null;
-    try {
-      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
-      const plan = await planner.planTransactions(input, { abortSignal });
-      if (currentExecutionId === executionId) {
-        transactionPlan.value = plan;
-        status.value = "planned";
-      }
-      return plan;
-    } catch (cause) {
-      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
-      if (currentExecutionId === executionId) {
-        error.value = normalizedError;
-        status.value = "error";
-      }
-      throw normalizedError;
-    } finally {
-      if (currentExecutionId === executionId) {
-        loading.value = false;
-      }
-    }
-  }
-  return {
-    transactionPlan,
-    status,
-    loading,
-    error,
-    execute
-  };
-}
-
-exports.usePlanTransaction = usePlanTransaction;
-exports.usePlanTransactions = usePlanTransactions;

package/dist/shared/vue.DxM45azl.cjs

@@ -1,173 +0,0 @@
-'use strict';
-
-const kit = require('@vue-solana/core/kit');
-const errors = require('@vue-solana/core/errors');
-const vue = require('vue');
-
-function isActionSource(value) {
-  return typeof value === "object" && value !== null && "reactiveStore" in value && typeof value.reactiveStore === "function";
-}
-function useTrackedData(source, options = {}) {
-  const data = vue.shallowRef(void 0);
-  const error = vue.shallowRef(null);
-  const status = vue.shallowRef("loading");
-  const disposables = [];
-  let connectionCount = 0;
-  let disposed = false;
-  let activeStore;
-  function applyState(state) {
-    if (state.status === "loaded") {
-      data.value = state.data;
-      error.value = null;
-      status.value = "loaded";
-    } else if (state.status === "error") {
-      error.value = errors.normalizeSolanaError(state.error, "RPC_FAILURE");
-      status.value = "error";
-      options.onError?.(state.error);
-    } else if (state.status === "loading") {
-      status.value = data.value === void 0 ? "loading" : status.value;
-    } else if (state.status === "idle") {
-      error.value = null;
-    }
-  }
-  function buildAndConnect(override) {
-    if (disposed) {
-      return;
-    }
-    let rpcRequest = vue.unref(source.rpcRequest);
-    const rpcSubscriptionRequest = vue.unref(source.rpcSubscriptionRequest);
-    if (!rpcRequest || !rpcSubscriptionRequest) {
-      disconnect();
-      data.value = void 0;
-      error.value = null;
-      status.value = "disabled";
-      return;
-    }
-    if (!isActionSource(rpcRequest) && isSendSource(rpcRequest)) {
-      let runSend = function(abortSignal) {
-        controller?.abort();
-        controller = new AbortController();
-        const composed = abortSignal ? AbortSignal.any([controller.signal, abortSignal]) : controller.signal;
-        settle({ data: void 0, error: void 0, status: "running" });
-        const pending = Promise.resolve(sendSource.send({ abortSignal: composed }));
-        pending.then((response) => {
-          settle({ data: response, error: void 0, status: "success" });
-        }).catch((cause) => {
-          settle({ data: void 0, error: cause, status: "error" });
-        });
-        return kit.getAbortablePromise(pending, composed);
-      };
-      const sendSource = rpcRequest;
-      const listeners = /* @__PURE__ */ new Set();
-      let sendState = {
-        data: void 0,
-        error: void 0,
-        status: "idle"
-      };
-      let controller;
-      const emit = () => {
-        listeners.forEach((listener) => {
-          listener();
-        });
-      };
-      const settle = (next) => {
-        sendState = next;
-        emit();
-      };
-      rpcRequest = {
-        reactiveStore: () => ({
-          dispatch() {
-            void runSend().catch(() => {
-            });
-          },
-          dispatchAsync: () => runSend(),
-          getState: () => sendState,
-          reset() {
-            controller?.abort();
-            settle({ data: void 0, error: void 0, status: "idle" });
-          },
-          subscribe(listener) {
-            listeners.add(listener);
-            return () => {
-              listeners.delete(listener);
-            };
-          },
-          withSignal(signal) {
-            return {
-              dispatch: () => {
-                void runSend(signal).catch(() => {
-                });
-              },
-              dispatchAsync: () => runSend(signal)
-            };
-          }
-        })
-      };
-    }
-    connectionCount += 1;
-    const connection = connectionCount;
-    const callerSignal = override ? override.abortSignal : options.getAbortSignal?.(connection);
-    const store = kit.createReactiveStoreWithInitialValueAndSlotTracking({
-      initialValueMapper: source.rpcValueMapper,
-      initialValueSource: rpcRequest,
-      streamSource: rpcSubscriptionRequest,
-      streamValueMapper: source.rpcSubscriptionValueMapper
-    });
-    activeStore = store;
-    applyState(store.getState());
-    disposables.push(
-      store.subscribe(() => {
-        applyState(store.getState());
-      })
-    );
-    if (callerSignal?.aborted) {
-      applyState({ data: store.getState().data, error: callerSignal.reason, status: "error" });
-      return;
-    }
-    if (callerSignal) {
-      store.withSignal(callerSignal).connect();
-    } else {
-      store.connect();
-    }
-  }
-  function disconnect() {
-    disposables.forEach((dispose) => {
-      dispose();
-    });
-    disposables.length = 0;
-    if (activeStore) {
-      activeStore.reset();
-      activeStore = void 0;
-    }
-  }
-  vue.watch(
-    () => [vue.unref(source.rpcRequest), vue.unref(source.rpcSubscriptionRequest)],
-    () => {
-      buildAndConnect();
-    },
-    { flush: "post" }
-  );
-  vue.onMounted(() => {
-    buildAndConnect();
-  });
-  if (!vue.getCurrentInstance()) {
-    buildAndConnect();
-  }
-  vue.onScopeDispose(() => {
-    disposed = true;
-    disconnect();
-  });
-  return {
-    data: vue.computed(() => data.value),
-    error: vue.computed(() => error.value),
-    refresh: (options2) => {
-      buildAndConnect(options2);
-    },
-    status: vue.computed(() => status.value)
-  };
-}
-function isSendSource(value) {
-  return typeof value === "object" && value !== null && "send" in value && typeof value.send === "function";
-}
-
-exports.useTrackedData = useTrackedData;

package/dist/shared/vue.E_npPFoV.cjs

@@ -1,67 +0,0 @@
-'use strict';
-
-const address = require('@vue-solana/core/address');
-const errors = require('@vue-solana/core/errors');
-const vue = require('vue');
-const useConnection = require('./vue.BVaMoz9y.cjs');
-const useSolana = require('./vue.DE3emjSF.cjs');
-
-function useBalance(address$1, commitment) {
-  const solana = useSolana.tryUseSolana();
-  const client = solana?.client ?? useConnection.useConnection();
-  const balance = vue.shallowRef(null);
-  const loading = vue.shallowRef(false);
-  const error = vue.shallowRef(null);
-  let refreshId = 0;
-  async function refresh() {
-    const requestId = ++refreshId;
-    const value = vue.toValue(address$1);
-    if (!value || !solana) {
-      balance.value = null;
-      loading.value = false;
-      error.value = null;
-      return null;
-    }
-    loading.value = true;
-    error.value = null;
-    try {
-      const parsedAddress = address.parseAddress(value);
-      if (!parsedAddress) {
-        balance.value = null;
-        return null;
-      }
-      const { value: lamports } = await client.rpc.getBalance(parsedAddress, commitment ? { commitment } : void 0).send();
-      if (requestId === refreshId) {
-        balance.value = Number(lamports);
-      }
-      return Number(lamports);
-    } catch (cause) {
-      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
-      if (requestId === refreshId) {
-        error.value = normalizedError;
-      }
-      throw normalizedError;
-    } finally {
-      if (requestId === refreshId) {
-        loading.value = false;
-      }
-    }
-  }
-  vue.onMounted(() => {
-    void refresh().catch(() => void 0);
-  });
-  vue.watch(
-    () => vue.toValue(address$1),
-    () => {
-      void refresh().catch(() => void 0);
-    }
-  );
-  return {
-    balance,
-    loading,
-    error,
-    refresh
-  };
-}
-
-exports.useBalance = useBalance;

package/dist/shared/vue.FiMmnMHr.cjs

@@ -1,20 +0,0 @@
-'use strict';
-
-const vue = require('vue');
-const useSolana = require('./vue.DE3emjSF.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,
-    client: solana.client
-  };
-}
-
-exports.useRpc = useRpc;

package/dist/shared/vue.JUWqu6kD.mjs

@@ -1,61 +0,0 @@
-import { normalizeSolanaError } from '@vue-solana/core/errors';
-import { createNoWalletSelectedError, assertWalletCanSignMessage } from '@vue-solana/core/wallet';
-import { ref } from 'vue';
-import { u as useWallet } from './vue.D218Ow7t.mjs';
-
-function useSignMessage() {
-  const { wallet } = useWallet();
-  const signedMessage = ref(null);
-  const signature = ref(null);
-  const status = ref("idle");
-  const loading = ref(false);
-  const error = ref(null);
-  let executionId = 0;
-  async function execute(message) {
-    const currentExecutionId = ++executionId;
-    status.value = "signing";
-    loading.value = true;
-    error.value = null;
-    signedMessage.value = null;
-    signature.value = null;
-    const activeWallet = wallet.value;
-    if (!activeWallet) {
-      const normalizedError = createNoWalletSelectedError();
-      error.value = normalizedError;
-      status.value = "error";
-      loading.value = false;
-      throw normalizedError;
-    }
-    try {
-      assertWalletCanSignMessage(activeWallet);
-      const result = await activeWallet.signMessage(message);
-      if (currentExecutionId === executionId) {
-        signedMessage.value = result.signedMessage;
-        signature.value = result.signature;
-        status.value = "signed";
-      }
-      return result;
-    } catch (cause) {
-      const normalizedError = normalizeSolanaError(cause, "RPC_FAILURE");
-      if (currentExecutionId === executionId) {
-        error.value = normalizedError;
-        status.value = "error";
-      }
-      throw normalizedError;
-    } finally {
-      if (currentExecutionId === executionId) {
-        loading.value = false;
-      }
-    }
-  }
-  return {
-    signedMessage,
-    signature,
-    status,
-    loading,
-    error,
-    execute
-  };
-}
-
-export { useSignMessage as u };

package/dist/shared/vue.Sbbm9JSu.cjs

@@ -1,74 +0,0 @@
-'use strict';
-
-const transaction = require('@vue-solana/core/transaction');
-const errors = require('@vue-solana/core/errors');
-const vue = require('vue');
-const useConnection = require('./vue.BVaMoz9y.cjs');
-
-function getConfirmedTransactionStatus(confirmation) {
-  if (confirmation.commitment === "finalized") {
-    return "finalized";
-  }
-  return confirmation.commitment === "processed" ? "processed" : "confirmed";
-}
-function useTransactionConfirmation(defaultOptions = {}) {
-  const client = useConnection.useConnection();
-  const signature = vue.ref(null);
-  const confirmation = vue.ref(null);
-  const status = vue.ref("idle");
-  const loading = vue.ref(false);
-  const error = vue.ref(null);
-  let executionId = 0;
-  async function confirm(nextSignature, options = {}) {
-    const currentExecutionId = ++executionId;
-    const confirmationOptions = { ...defaultOptions, ...options };
-    signature.value = nextSignature;
-    confirmation.value = null;
-    status.value = "confirming";
-    loading.value = true;
-    error.value = null;
-    try {
-      const nextConfirmation = await transaction.confirmTransactionSignature(
-        client,
-        nextSignature,
-        confirmationOptions
-      );
-      if (currentExecutionId === executionId) {
-        confirmation.value = nextConfirmation;
-        status.value = getConfirmedTransactionStatus(nextConfirmation);
-      }
-      return nextConfirmation;
-    } catch (cause) {
-      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
-      if (currentExecutionId === executionId) {
-        error.value = normalizedError;
-        status.value = "error";
-      }
-      throw normalizedError;
-    } finally {
-      if (currentExecutionId === executionId) {
-        loading.value = false;
-      }
-    }
-  }
-  function reset() {
-    executionId += 1;
-    signature.value = null;
-    confirmation.value = null;
-    status.value = "idle";
-    loading.value = false;
-    error.value = null;
-  }
-  return {
-    signature,
-    confirmation,
-    status,
-    loading,
-    error,
-    confirm,
-    reset
-  };
-}
-
-exports.getConfirmedTransactionStatus = getConfirmedTransactionStatus;
-exports.useTransactionConfirmation = useTransactionConfirmation;