@vue-solana/vue 1.2.0 → 2.1.0

package/dist/shared/vue.DtCbCcPd.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() {
+    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 = 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: () => {
+      buildAndConnect();
+    },
+    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.CM_uqVc0.mjs → vue.Dyi1OCI1.mjs}

@@ -3,13 +3,13 @@ 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.DiNn3XHm.mjs';
-import { u as useWallet } from './vue.B2AQR2bE.mjs';
-import { g as getConfirmedTransactionStatus } from './vue.QHAHFnw8.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() {
-  const connection = useConnection();
+  const client = useConnection();
   const { wallet } = useWallet();
   const signature = ref(null);
   const confirmation = ref(null);
@@ -35,7 +35,7 @@ function useSignAndSendTransaction() {
     }
     try {
       const nextSignature = await withSolanaTimeout(
-        signAndSendTransaction(connection, activeWallet, transaction, transactionOptions),
+        signAndSendTransaction(client, activeWallet, transaction, transactionOptions),
         SIGN_AND_SEND_TIMEOUT_MS,
         "Wallet transaction did not return a result. Check your wallet or explorer for the final status."
       );
@@ -47,7 +47,7 @@ function useSignAndSendTransaction() {
         return nextSignature;
       }
       const nextConfirmation = await confirmTransactionSignature(
-        connection,
+        client,
         nextSignature,
         confirmationOptions
       );

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

@@ -3,12 +3,12 @@
 const address = require('@vue-solana/core/address');
 const errors = require('@vue-solana/core/errors');
 const vue = require('vue');
-const useConnection = require('./vue.DCgByzxg.cjs');
-const useSolana = require('./vue.BE4KHksm.cjs');
+const useConnection = require('./vue.BVaMoz9y.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 
 function useBalance(address$1, commitment) {
   const solana = useSolana.tryUseSolana();
-  const connection = solana?.connection ?? useConnection.useConnection();
+  const client = solana?.client ?? useConnection.useConnection();
   const balance = vue.shallowRef(null);
   const loading = vue.shallowRef(false);
   const error = vue.shallowRef(null);
@@ -25,16 +25,16 @@ function useBalance(address$1, commitment) {
     loading.value = true;
     error.value = null;
     try {
-      const publicKey = address.parsePublicKey(value);
-      if (!publicKey) {
+      const parsedAddress = address.parseAddress(value);
+      if (!parsedAddress) {
         balance.value = null;
         return null;
       }
-      const nextBalance = await connection.getBalance(publicKey, commitment);
+      const { value: lamports } = await client.rpc.getBalance(parsedAddress, commitment ? { commitment } : void 0).send();
       if (requestId === refreshId) {
-        balance.value = nextBalance;
+        balance.value = Number(lamports);
       }
-      return nextBalance;
+      return Number(lamports);
     } catch (cause) {
       const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
       if (requestId === refreshId) {

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

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const useSolana = require('./vue.BE4KHksm.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 
 function useRpc() {
   const solana = useSolana.useSolana();
@@ -13,7 +13,7 @@ function useRpc() {
     error: solana.error,
     latestBlockhash: solana.latestBlockhash,
     checkConnection: solana.checkConnection,
-    connection: solana.connection
+    client: solana.client
   };
 }
 

package/dist/shared/{vue.CSzg70vB.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.B2AQR2bE.mjs';
+import { u as useWallet } from './vue.D218Ow7t.mjs';
 
 function useSignMessage() {
   const { wallet } = useWallet();

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

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

package/dist/shared/{vue.ByUemLSf.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.DCgByzxg.cjs');
+const useConnection = require('./vue.BVaMoz9y.cjs');
 
 function getConfirmedTransactionStatus(confirmation) {
   if (confirmation.commitment === "finalized") {
@@ -12,7 +12,7 @@ function getConfirmedTransactionStatus(confirmation) {
   return confirmation.commitment === "processed" ? "processed" : "confirmed";
 }
 function useTransactionConfirmation(defaultOptions = {}) {
-  const connection = useConnection.useConnection();
+  const client = useConnection.useConnection();
   const signature = vue.ref(null);
   const confirmation = vue.ref(null);
   const status = vue.ref("idle");
@@ -29,7 +29,7 @@ function useTransactionConfirmation(defaultOptions = {}) {
     error.value = null;
     try {
       const nextConfirmation = await transaction.confirmTransactionSignature(
-        connection,
+        client,
         nextSignature,
         confirmationOptions
       );

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;

package/dist/swr.cjs

@@ -0,0 +1,136 @@
+'use strict';
+
+const vue = require('vue');
+const useRequest = require('./shared/vue.B8pLQ8P4.cjs');
+const useSubscription = require('./shared/vue.BVj9lWBK.cjs');
+const useTrackedData = require('./shared/vue.DtCbCcPd.cjs');
+require('@vue-solana/core/action');
+require('@vue-solana/core/kit');
+require('@vue-solana/core/errors');
+
+const PREFIX_REQUEST = "request:";
+const PREFIX_SUBSCRIPTION = "subscription:";
+const PREFIX_TRACKED = "tracked:";
+const swrCache = /* @__PURE__ */ new Map();
+function clearSwrCache() {
+  swrCache.clear();
+}
+function readSwrCache(key) {
+  return swrCache.get(key);
+}
+function writeSwrCache(key, entry) {
+  swrCache.set(key, entry);
+}
+function deleteSwrCache(key) {
+  swrCache.delete(key);
+}
+function isPendingStatus(status) {
+  return status === "fetching" || status === "loading";
+}
+function writeSwrResult(key, data, error, status) {
+  if (status === "disabled") {
+    deleteSwrCache(key);
+    return;
+  }
+  const previous = readSwrCache(key);
+  writeSwrCache(key, {
+    data: data !== void 0 ? data : previous?.data,
+    error,
+    status
+  });
+}
+function swrError(error, status, seed) {
+  if (status === "disabled") {
+    return null;
+  }
+  return error ?? (isPendingStatus(status) ? seed?.error ?? null : null);
+}
+function useRequestSwr(key, source, options = {}) {
+  const cacheKey = `${PREFIX_REQUEST}${key}`;
+  const seed = readSwrCache(cacheKey);
+  const result = useRequest.useRequest(source, options);
+  if (result.status.value === "disabled") {
+    deleteSwrCache(cacheKey);
+  }
+  vue.watch(
+    [result.data, result.error, result.status],
+    ([data2, error2, status]) => writeSwrResult(cacheKey, data2, error2, status),
+    { flush: "sync" }
+  );
+  const data = vue.computed(() => {
+    if (result.status.value === "disabled") {
+      return void 0;
+    }
+    return result.data.value !== void 0 ? result.data.value : seed?.data;
+  });
+  const error = vue.computed(
+    () => swrError(result.error.value, result.status.value, seed)
+  );
+  return {
+    data,
+    error,
+    refresh: result.refresh,
+    status: result.status
+  };
+}
+function useSubscriptionSwr(key, source, options = {}) {
+  const cacheKey = `${PREFIX_SUBSCRIPTION}${key}`;
+  const seed = readSwrCache(cacheKey);
+  const result = useSubscription.useSubscription(source, options);
+  if (result.status.value === "disabled") {
+    deleteSwrCache(cacheKey);
+  }
+  vue.watch(
+    [result.data, result.error, result.status],
+    ([data2, error2, status]) => writeSwrResult(cacheKey, data2, error2, status),
+    { flush: "sync" }
+  );
+  const data = vue.computed(() => {
+    if (result.status.value === "disabled") {
+      return void 0;
+    }
+    return result.data.value !== void 0 ? result.data.value : seed?.data;
+  });
+  const error = vue.computed(
+    () => swrError(result.error.value, result.status.value, seed)
+  );
+  return {
+    data,
+    error,
+    reconnect: result.reconnect,
+    status: result.status
+  };
+}
+function useTrackedDataSwr(key, source, options = {}) {
+  const cacheKey = `${PREFIX_TRACKED}${key}`;
+  const seed = readSwrCache(cacheKey);
+  const result = useTrackedData.useTrackedData(source, options);
+  if (result.status.value === "disabled") {
+    deleteSwrCache(cacheKey);
+  }
+  vue.watch(
+    [result.data, result.error, result.status],
+    ([data2, error2, status]) => writeSwrResult(cacheKey, data2, error2, status),
+    { flush: "sync" }
+  );
+  const data = vue.computed(() => {
+    if (result.status.value === "disabled") {
+      return void 0;
+    }
+    return result.data.value ?? seed?.data;
+  });
+  const error = vue.computed(
+    () => swrError(result.error.value, result.status.value, seed)
+  );
+  return {
+    data,
+    error,
+    refresh: result.refresh,
+    status: result.status
+  };
+}
+
+exports.clearSwrCache = clearSwrCache;
+exports.useRequestSwr = useRequestSwr;
+exports.useSubscriptionSwr = useSubscriptionSwr;
+exports.useTrackedDataSwr = useTrackedDataSwr;

package/dist/swr.d.cts

@@ -0,0 +1,41 @@
+import { useRequest, UseRequestOptions, UseRequestReturn } from './useRequest.cjs';
+import { UseSubscriptionSource, UseSubscriptionOptions, UseSubscriptionReturn } from './useSubscription.cjs';
+import { UseTrackedDataSource, UseTrackedDataOptions, UseTrackedDataReturn } from './useTrackedData.cjs';
+import '@vue-solana/core/errors';
+import 'vue';
+import '@vue-solana/core/kit';
+
+/**
+ * Remove every cached SWR entry (all adapters). Useful between test cases
+ * and to reset server-side caches per request.
+ */
+declare function clearSwrCache(): void;
+/**
+ * `useRequest` with cache keying. A component mounting with a key that
+ * already holds data shows it immediately (stale) while its own request
+ * revalidates; results are written back for the next mount.
+ *
+ * A `null`/`undefined` source disables the request and **clears** the
+ * cached entry for the key — including when the component mounts with the
+ * source already disabled.
+ */
+declare function useRequestSwr<TResult>(key: string, source: Parameters<typeof useRequest<TResult>>[0], options?: UseRequestOptions): UseRequestReturn<TResult>;
+/**
+ * `useSubscription` with cache keying — a freshly mounted component seeds
+ * from the last-known stream value while its own subscription connects.
+ *
+ * A `null`/`undefined` source disables the subscription and **clears** the
+ * cached entry for the key.
+ */
+declare function useSubscriptionSwr<TResult>(key: string, source: UseSubscriptionSource<TResult>, options?: UseSubscriptionOptions): UseSubscriptionReturn<TResult>;
+/**
+ * `useTrackedData` with cache keying — seeds from the last-known
+ * {@link SolanaRpcResponse} envelope (data **and** slot context) while the
+ * fetch + subscription pair revalidates.
+ *
+ * A `null`/`undefined` source disables the composable and **clears** the
+ * cached entry for the key.
+ */
+declare function useTrackedDataSwr<TInitialValue, TStreamValue, TItem>(key: string, source: UseTrackedDataSource<TInitialValue, TStreamValue, TItem>, options?: UseTrackedDataOptions): UseTrackedDataReturn<TItem>;
+
+export { clearSwrCache, useRequestSwr, useSubscriptionSwr, useTrackedDataSwr };

package/dist/swr.d.mts

@@ -0,0 +1,41 @@
+import { useRequest, UseRequestOptions, UseRequestReturn } from './useRequest.mjs';
+import { UseSubscriptionSource, UseSubscriptionOptions, UseSubscriptionReturn } from './useSubscription.mjs';
+import { UseTrackedDataSource, UseTrackedDataOptions, UseTrackedDataReturn } from './useTrackedData.mjs';
+import '@vue-solana/core/errors';
+import 'vue';
+import '@vue-solana/core/kit';
+
+/**
+ * Remove every cached SWR entry (all adapters). Useful between test cases
+ * and to reset server-side caches per request.
+ */
+declare function clearSwrCache(): void;
+/**
+ * `useRequest` with cache keying. A component mounting with a key that
+ * already holds data shows it immediately (stale) while its own request
+ * revalidates; results are written back for the next mount.
+ *
+ * A `null`/`undefined` source disables the request and **clears** the
+ * cached entry for the key — including when the component mounts with the
+ * source already disabled.
+ */
+declare function useRequestSwr<TResult>(key: string, source: Parameters<typeof useRequest<TResult>>[0], options?: UseRequestOptions): UseRequestReturn<TResult>;
+/**
+ * `useSubscription` with cache keying — a freshly mounted component seeds
+ * from the last-known stream value while its own subscription connects.
+ *
+ * A `null`/`undefined` source disables the subscription and **clears** the
+ * cached entry for the key.
+ */
+declare function useSubscriptionSwr<TResult>(key: string, source: UseSubscriptionSource<TResult>, options?: UseSubscriptionOptions): UseSubscriptionReturn<TResult>;
+/**
+ * `useTrackedData` with cache keying — seeds from the last-known
+ * {@link SolanaRpcResponse} envelope (data **and** slot context) while the
+ * fetch + subscription pair revalidates.
+ *
+ * A `null`/`undefined` source disables the composable and **clears** the
+ * cached entry for the key.
+ */
+declare function useTrackedDataSwr<TInitialValue, TStreamValue, TItem>(key: string, source: UseTrackedDataSource<TInitialValue, TStreamValue, TItem>, options?: UseTrackedDataOptions): UseTrackedDataReturn<TItem>;
+
+export { clearSwrCache, useRequestSwr, useSubscriptionSwr, useTrackedDataSwr };

package/dist/swr.d.ts

@@ -0,0 +1,41 @@
+import { useRequest, UseRequestOptions, UseRequestReturn } from './useRequest.js';
+import { UseSubscriptionSource, UseSubscriptionOptions, UseSubscriptionReturn } from './useSubscription.js';
+import { UseTrackedDataSource, UseTrackedDataOptions, UseTrackedDataReturn } from './useTrackedData.js';
+import '@vue-solana/core/errors';
+import 'vue';
+import '@vue-solana/core/kit';
+
+/**
+ * Remove every cached SWR entry (all adapters). Useful between test cases
+ * and to reset server-side caches per request.
+ */
+declare function clearSwrCache(): void;
+/**
+ * `useRequest` with cache keying. A component mounting with a key that
+ * already holds data shows it immediately (stale) while its own request
+ * revalidates; results are written back for the next mount.
+ *
+ * A `null`/`undefined` source disables the request and **clears** the
+ * cached entry for the key — including when the component mounts with the
+ * source already disabled.
+ */
+declare function useRequestSwr<TResult>(key: string, source: Parameters<typeof useRequest<TResult>>[0], options?: UseRequestOptions): UseRequestReturn<TResult>;
+/**
+ * `useSubscription` with cache keying — a freshly mounted component seeds
+ * from the last-known stream value while its own subscription connects.
+ *
+ * A `null`/`undefined` source disables the subscription and **clears** the
+ * cached entry for the key.
+ */
+declare function useSubscriptionSwr<TResult>(key: string, source: UseSubscriptionSource<TResult>, options?: UseSubscriptionOptions): UseSubscriptionReturn<TResult>;
+/**
+ * `useTrackedData` with cache keying — seeds from the last-known
+ * {@link SolanaRpcResponse} envelope (data **and** slot context) while the
+ * fetch + subscription pair revalidates.
+ *
+ * A `null`/`undefined` source disables the composable and **clears** the
+ * cached entry for the key.
+ */
+declare function useTrackedDataSwr<TInitialValue, TStreamValue, TItem>(key: string, source: UseTrackedDataSource<TInitialValue, TStreamValue, TItem>, options?: UseTrackedDataOptions): UseTrackedDataReturn<TItem>;
+
+export { clearSwrCache, useRequestSwr, useSubscriptionSwr, useTrackedDataSwr };