@vue-solana/vue 2.0.0 → 2.2.0

package/dist/shared/vue.DFaMJLAQ.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+const errors = require('@vue-solana/core/errors');
+const wallet = require('@vue-solana/core/wallet');
+const vue = require('vue');
+const useWallet = require('./vue.BGxz4dru.cjs');
+
+function useSignTransactions() {
+  const { wallet: wallet$1 } = useWallet.useWallet();
+  const signedTransactions = vue.shallowRef(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  async function execute(transactions) {
+    const currentExecutionId = ++executionId;
+    status.value = "signing";
+    loading.value = true;
+    error.value = null;
+    signedTransactions.value = null;
+    const activeWallet = wallet$1.value;
+    if (!activeWallet) {
+      const normalizedError = wallet.createNoWalletSelectedError();
+      error.value = normalizedError;
+      status.value = "error";
+      loading.value = false;
+      throw normalizedError;
+    }
+    try {
+      wallet.assertWalletCanSignTransactions(activeWallet);
+      const sign = activeWallet.signTransactions ? activeWallet.signTransactions.bind(activeWallet) : activeWallet.signAllTransactions.bind(activeWallet);
+      const result = await sign([...transactions]);
+      if (currentExecutionId === executionId) {
+        signedTransactions.value = result;
+        status.value = "signed";
+      }
+      return result;
+    } 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 {
+    signedTransactions,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+
+exports.useSignTransactions = useSignTransactions;

package/dist/shared/{vue.DgCmU1RR.cjs → vue.DKyQ7J67.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-const useSolana = require('./vue.BaR1VPhl.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 
 function useWallets() {
   const solana = useSolana.useSolana();

package/dist/shared/vue.DXQVIRZA.mjs

@@ -0,0 +1,174 @@
+import { provide, inject, ref, watch, getCurrentScope, onScopeDispose, computed, defineComponent } from 'vue';
+import { s as solanaInjectionKey } from './vue.D_P5SqqD.mjs';
+
+const SELECTED_WALLET_ACCOUNT_STORAGE_KEY = "vue-solana:selected-wallet-account";
+function createLocalStorageSelectedWalletAccountStorage(storage = defaultLocalStorage()) {
+  return {
+    storeSelectedWallet(key) {
+      try {
+        storage?.setItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY, key);
+      } catch {
+      }
+    },
+    getSelectedWallet() {
+      try {
+        return storage?.getItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY) ?? null;
+      } catch {
+        return null;
+      }
+    },
+    deleteSelectedWallet() {
+      try {
+        storage?.removeItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY);
+      } catch {
+      }
+    }
+  };
+}
+function defaultLocalStorage() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+
+const selectedWalletAccountInjectionKey = Symbol.for("vue-solana:selected-wallet-account");
+function provideSelectedWalletAccount(options = {}) {
+  const context = createSelectedWalletAccountContext(options);
+  provide(selectedWalletAccountInjectionKey, context);
+  return context;
+}
+function createSelectedWalletAccountContext(options = {}, solanaContextOverride) {
+  const solanaContext = solanaContextOverride ?? inject(solanaInjectionKey, null);
+  const stateSync = options.stateSync === void 0 ? defaultStateSync() : options.stateSync;
+  const selectedWalletAccount = ref(null);
+  const walletsValue = () => solanaContext?.wallets.value ?? [];
+  let pendingKey = null;
+  let selectionGeneration = 0;
+  function findAccount(key) {
+    const separatorIndex = key.lastIndexOf(":");
+    const walletName = separatorIndex === -1 ? key : key.slice(0, separatorIndex);
+    const address = separatorIndex === -1 ? "" : key.slice(separatorIndex + 1);
+    const wallet = walletsValue().find((candidate) => candidate.name === walletName);
+    const account = wallet?.accounts.find((candidate) => candidate.address === address);
+    if (!wallet || !account) {
+      return null;
+    }
+    return { ...account, walletName: wallet.name };
+  }
+  function clearSelection() {
+    selectionGeneration += 1;
+    pendingKey = null;
+    selectedWalletAccount.value = null;
+  }
+  function applyExternalSelection(key) {
+    if (!key) {
+      clearSelection();
+      return;
+    }
+    const account = findAccount(key);
+    if (account) {
+      selectionGeneration += 1;
+      pendingKey = null;
+      selectedWalletAccount.value = account;
+      return;
+    }
+    pendingKey = key;
+  }
+  function restoreIfAvailable() {
+    if (!pendingKey || selectedWalletAccount.value) {
+      return;
+    }
+    const account = findAccount(pendingKey);
+    if (account) {
+      selectedWalletAccount.value = account;
+      pendingKey = null;
+    }
+  }
+  if (stateSync) {
+    const generation = selectionGeneration;
+    void Promise.resolve(stateSync.getSelectedWallet()).then((key) => {
+      if (generation !== selectionGeneration || !key || selectedWalletAccount.value) {
+        return;
+      }
+      pendingKey = key;
+      restoreIfAvailable();
+    }).catch(() => void 0);
+  }
+  if (solanaContext) {
+    watch(
+      () => solanaContext.wallets.value,
+      () => restoreIfAvailable()
+    );
+  }
+  if (stateSync && typeof window !== "undefined") {
+    const onStorage = () => {
+      void Promise.resolve(stateSync.getSelectedWallet()).then((key) => applyExternalSelection(key)).catch(() => void 0);
+    };
+    window.addEventListener("storage", onStorage);
+    if (getCurrentScope()) {
+      onScopeDispose(() => window.removeEventListener("storage", onStorage));
+    }
+  }
+  const context = {
+    selectedWalletAccount,
+    setSelectedWalletAccount(account) {
+      selectionGeneration += 1;
+      selectedWalletAccount.value = account;
+      pendingKey = null;
+      if (!stateSync) {
+        return;
+      }
+      const persisted = account ? stateSync.storeSelectedWallet(`${account.walletName}:${account.address}`) : stateSync.deleteSelectedWallet();
+      void Promise.resolve(persisted).catch(() => void 0);
+    },
+    filteredWallets: computed(() => {
+      const filter = options.filterWallet;
+      if (!filter) {
+        return walletsValue();
+      }
+      return walletsValue().map((wallet) => {
+        const accounts = wallet.accounts.filter((account) => filter(wallet.name, account));
+        return accounts.length === 0 ? null : { ...wallet, accounts };
+      }).filter((wallet) => wallet !== null);
+    })
+  };
+  return context;
+}
+function useSelectedWalletAccount() {
+  const context = inject(selectedWalletAccountInjectionKey, null);
+  if (!context) {
+    throw new Error("useSelectedWalletAccount must be used inside a SelectedWalletAccountProvider");
+  }
+  return [context.selectedWalletAccount, context.setSelectedWalletAccount, context.filteredWallets];
+}
+function defaultStateSync() {
+  return createLocalStorageSelectedWalletAccountStorage();
+}
+
+const SelectedWalletAccountProvider = defineComponent({
+  name: "SelectedWalletAccountProvider",
+  props: {
+    filterWallet: {
+      type: Function,
+      default: void 0
+    },
+    stateSync: {
+      type: [Object, null],
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    provideSelectedWalletAccount({
+      filterWallet: props.filterWallet,
+      stateSync: props.stateSync
+    });
+    return () => slots.default?.();
+  }
+});
+
+export { SelectedWalletAccountProvider as S, createSelectedWalletAccountContext as c, provideSelectedWalletAccount as p, selectedWalletAccountInjectionKey as s, useSelectedWalletAccount as u };

package/dist/shared/vue.DYk0Xfr3.mjs

@@ -0,0 +1,36 @@
+import { createSolanaActionStore } from '@vue-solana/core/action';
+import { unref, shallowRef, onScopeDispose, computed } from 'vue';
+
+function useAction(action, options = {}) {
+  const store = createSolanaActionStore(
+    (signal, ...args) => unref(action)(signal, ...args)
+  );
+  const state = shallowRef(store.getState());
+  const unsubscribe = store.subscribe(() => {
+    const next = store.getState();
+    const previous = state.value;
+    if (next.status === "success" && previous.status !== "success") {
+      options.onSuccess?.(next.data);
+    }
+    if (next.status === "error" && previous.status !== "error") {
+      options.onError?.(next.error);
+    }
+    state.value = next;
+  });
+  onScopeDispose(() => {
+    unsubscribe();
+    store.reset();
+  });
+  return {
+    data: computed(() => state.value.data),
+    dispatch: (...args) => store.dispatchAsync(...args),
+    error: computed(() => state.value.error),
+    isRunning: computed(() => state.value.status === "running"),
+    reset: () => {
+      store.reset();
+    },
+    status: computed(() => state.value.status)
+  };
+}
+
+export { useAction as u };

package/dist/shared/vue.D_P5SqqD.mjs

@@ -0,0 +1,5 @@
+const solanaInjectionKey = Symbol.for(
+  "vue-solana:context"
+);
+
+export { solanaInjectionKey as s };

package/dist/shared/{vue.C7yR7Cs0.cjs → vue.Di7yjJ-R.cjs}

@@ -3,8 +3,8 @@
 const errors = require('@vue-solana/core/errors');
 const vue = require('vue');
 const address = require('@vue-solana/core/address');
-const useConnection = require('./vue.CZwftA0L.cjs');
-const useSolana = require('./vue.BaR1VPhl.cjs');
+const useConnection = require('./vue.BVaMoz9y.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 const decodeBase64 = require('./vue.DNxOpDXz.cjs');
 
 function useProgramAccounts(programId, options = {}) {

package/dist/shared/vue.DxM45azl.cjs

@@ -0,0 +1,173 @@
+'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.WugzPOca.mjs → vue.Dyi1OCI1.mjs}

@@ -3,9 +3,9 @@ import { withSolanaTimeout } from '@vue-solana/core/timeout';
 import { signAndSendTransaction, confirmTransactionSignature } from '@vue-solana/core/transaction';
 import { createNoWalletSelectedError } from '@vue-solana/core/wallet';
 import { ref } from 'vue';
-import { u as useConnection } from './vue.ChujsB0B.mjs';
-import { u as useWallet } from './vue.PJjEncbP.mjs';
-import { g as getConfirmedTransactionStatus } from './vue.B2sFJ1xI.mjs';
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
+import { u as useWallet } from './vue.D218Ow7t.mjs';
+import { g as getConfirmedTransactionStatus } from './vue.D3Y0PWbF.mjs';
 
 const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
 function useSignAndSendTransaction() {

package/dist/shared/{vue.CEn2purG.cjs → vue.E_npPFoV.cjs}

@@ -3,8 +3,8 @@
 const address = require('@vue-solana/core/address');
 const errors = require('@vue-solana/core/errors');
 const vue = require('vue');
-const useConnection = require('./vue.CZwftA0L.cjs');
-const useSolana = require('./vue.BaR1VPhl.cjs');
+const useConnection = require('./vue.BVaMoz9y.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 
 function useBalance(address$1, commitment) {
   const solana = useSolana.tryUseSolana();

package/dist/shared/{vue.__r7YYZE.cjs → vue.FiMmnMHr.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const useSolana = require('./vue.BaR1VPhl.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 
 function useRpc() {
   const solana = useSolana.useSolana();

package/dist/shared/{vue.CZO8TwJP.mjs → vue.JUWqu6kD.mjs}

@@ -1,7 +1,7 @@
 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.PJjEncbP.mjs';
+import { u as useWallet } from './vue.D218Ow7t.mjs';
 
 function useSignMessage() {
   const { wallet } = useWallet();

package/dist/shared/{vue.BaFrF2PF.mjs → vue.Mxc8w6Qk.mjs}

@@ -1,4 +1,4 @@
-import { u as useSolana } from './vue.CnUlZSe8.mjs';
+import { u as useSolana } from './vue.CQh3AUE8.mjs';
 
 function useSolanaClient() {
   const { client } = useSolana();

package/dist/shared/{vue.C32ozdA1.cjs → vue.Sbbm9JSu.cjs}

@@ -3,7 +3,7 @@
 const transaction = require('@vue-solana/core/transaction');
 const errors = require('@vue-solana/core/errors');
 const vue = require('vue');
-const useConnection = require('./vue.CZwftA0L.cjs');
+const useConnection = require('./vue.BVaMoz9y.cjs');
 
 function getConfirmedTransactionStatus(confirmation) {
   if (confirmation.commitment === "finalized") {

package/dist/shared/vue.ZuUCEEab.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+const action = require('@vue-solana/core/action');
+const kit = require('@vue-solana/core/kit');
+const errors = require('@vue-solana/core/errors');
+const vue = require('vue');
+
+function useRequest(source, options = {}) {
+  const data = vue.shallowRef(void 0);
+  const error = vue.shallowRef(null);
+  const status = vue.shallowRef("fetching");
+  let disposed = false;
+  let attempt = 0;
+  const store = action.createSolanaActionStore(async (signal, resolved, override) => {
+    attempt += 1;
+    const callerSignal = override ? override.abortSignal : options.getAbortSignal?.(attempt);
+    const composedSignal = callerSignal ? AbortSignal.any([signal, callerSignal]) : signal;
+    let pending;
+    if (isSendSource(resolved)) {
+      pending = Promise.resolve(resolved.send({ abortSignal: composedSignal }));
+    } else if (typeof resolved === "function") {
+      pending = Promise.resolve(resolved(composedSignal)).then(
+        (result) => isSendSource(result) ? result.send({ abortSignal: composedSignal }) : result
+      );
+    } else {
+      throw new Error("useRequest source did not resolve to a request function");
+    }
+    return kit.getAbortablePromise(pending, composedSignal);
+  });
+  const unsubscribe = store.subscribe(() => {
+    const next = store.getState();
+    if (next.status === "success") {
+      data.value = next.data;
+      error.value = null;
+      status.value = "success";
+    } else if (next.status === "error") {
+      error.value = errors.normalizeSolanaError(next.error, "RPC_FAILURE");
+      status.value = "error";
+    } else if (next.status === "running") {
+      status.value = "fetching";
+    }
+  });
+  vue.onScopeDispose(() => {
+    disposed = true;
+    unsubscribe();
+    store.reset();
+  });
+  function unwrapSource() {
+    if (vue.isRef(source)) {
+      return source.value;
+    }
+    return source;
+  }
+  async function run(override) {
+    if (disposed) {
+      return void 0;
+    }
+    const resolved = unwrapSource();
+    if (isDisabled(resolved)) {
+      data.value = void 0;
+      error.value = null;
+      status.value = "disabled";
+      store.reset();
+      return void 0;
+    }
+    status.value = "fetching";
+    try {
+      return await store.dispatchAsync(resolved, override);
+    } catch (cause) {
+      if (store.getState().status !== "error") {
+        return void 0;
+      }
+      throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
+    }
+  }
+  const refresh = (options2) => run(options2);
+  vue.watch(
+    () => vue.isRef(source) ? source.value : source,
+    () => {
+      void refresh().catch(() => void 0);
+    }
+  );
+  vue.onMounted(() => {
+    void refresh().catch(() => void 0);
+  });
+  if (!vue.getCurrentInstance()) {
+    void refresh().catch(() => void 0);
+  }
+  return {
+    data: vue.computed(() => data.value),
+    error: vue.computed(() => error.value),
+    refresh,
+    status: vue.computed(() => status.value)
+  };
+}
+function isDisabled(resolved) {
+  return resolved === null || resolved === void 0;
+}
+function isSendSource(resolved) {
+  return typeof resolved === "object" && resolved !== null && "send" in resolved && typeof resolved.send === "function";
+}
+
+exports.useRequest = useRequest;

package/dist/shared/vue.g8fnm_ca.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+const vue = require('vue');
+const useClientCapability = require('./vue.BY0qpgYr.cjs');
+const useSolanaClient = require('./vue.BIxphCAq.cjs');
+
+function useIdentity() {
+  useClientCapability.useClientCapability(["identity"], {
+    hookName: "useIdentity",
+    providerHint: "Install a signer plugin, e.g. `createClient().use(generatedIdentity())` from `@solana/kit-plugin-signer`."
+  });
+  const { client } = useSolanaClient.useSolanaClient();
+  const identity = vue.shallowRef(
+    client.identity
+  );
+  const subscribable = client;
+  if (typeof subscribable.subscribeToIdentity === "function") {
+    const unsubscribe = subscribable.subscribeToIdentity(() => {
+      identity.value = client.identity;
+    });
+    vue.onScopeDispose(unsubscribe);
+  }
+  return identity;
+}
+function usePayer() {
+  useClientCapability.useClientCapability(["payer"], {
+    hookName: "usePayer",
+    providerHint: "Install a signer plugin, e.g. `createClient().use(generatedPayer())` from `@solana/kit-plugin-signer`."
+  });
+  const { client } = useSolanaClient.useSolanaClient();
+  const payer = vue.shallowRef(
+    client.payer
+  );
+  const subscribable = client;
+  if (typeof subscribable.subscribeToPayer === "function") {
+    const unsubscribe = subscribable.subscribeToPayer(() => {
+      payer.value = client.payer;
+    });
+    vue.onScopeDispose(unsubscribe);
+  }
+  return payer;
+}
+
+exports.useIdentity = useIdentity;
+exports.usePayer = usePayer;