@use-stellar/vue 0.0.0-stage → 0.2.3

package/dist/index.js

@@ -0,0 +1,829 @@
+'use strict';
+
+var vue = require('vue');
+var core = require('use-stellar/core');
+
+// src/plugin.ts
+
+// src/types.ts
+var NETWORK_PASSPHRASES = {
+  testnet: "Test SDF Network ; September 2015",
+  mainnet: "Public Global Stellar Network ; September 2015",
+  futurenet: "Test SDF Future Network ; October 2022"
+};
+var NETWORK_CONFIGS = {
+  testnet: {
+    network: "testnet",
+    horizonUrl: "https://horizon-testnet.stellar.org",
+    sorobanUrl: "https://soroban-testnet.stellar.org",
+    networkPassphrase: NETWORK_PASSPHRASES.testnet
+  },
+  mainnet: {
+    network: "mainnet",
+    horizonUrl: "https://horizon.stellar.org",
+    sorobanUrl: "https://soroban.stellar.org",
+    networkPassphrase: NETWORK_PASSPHRASES.mainnet
+  },
+  futurenet: {
+    network: "futurenet",
+    horizonUrl: "https://horizon-futurenet.stellar.org",
+    sorobanUrl: "https://rpc-futurenet.stellar.org",
+    networkPassphrase: NETWORK_PASSPHRASES.futurenet
+  }
+};
+
+// src/plugin.ts
+var STELLAR_RUNTIME_KEY = /* @__PURE__ */ Symbol("use-stellar/vue:runtime");
+var DISCONNECTED_WALLET = {
+  connected: false,
+  connecting: false,
+  address: null,
+  network: null,
+  wallet: null,
+  walletName: null,
+  error: null,
+  walletNetwork: null,
+  walletNetworkPassphrase: null
+};
+function resolveNetworkConfig(network, override) {
+  const builtIn = NETWORK_CONFIGS[network];
+  if (!override) return builtIn;
+  return {
+    network,
+    horizonUrl: override.horizonUrl ?? builtIn.horizonUrl,
+    sorobanUrl: override.sorobanUrl ?? builtIn.sorobanUrl,
+    networkPassphrase: override.networkPassphrase ?? builtIn.networkPassphrase
+  };
+}
+function createStellarRuntime(options = {}) {
+  const network = options.network ?? "testnet";
+  const walletAddress = vue.shallowRef(options.walletAddress ?? null);
+  const runtime = {
+    network,
+    networkConfig: resolveNetworkConfig(network, options.networkConfig),
+    queryStore: new core.QueryStore(options.queryConfig),
+    wallet: { ...DISCONNECTED_WALLET, address: options.walletAddress ?? null },
+    setWallet(wallet) {
+      runtime.wallet = wallet;
+      walletAddress.value = wallet.address;
+    },
+    walletAddress,
+    setWalletAddress(address) {
+      walletAddress.value = address;
+    }
+  };
+  return runtime;
+}
+function createStellarPlugin(options = {}) {
+  return {
+    install(app) {
+      app.provide(STELLAR_RUNTIME_KEY, createStellarRuntime(options));
+    }
+  };
+}
+function useStellarRuntime() {
+  const runtime = vue.inject(STELLAR_RUNTIME_KEY);
+  if (!runtime) {
+    throw new Error(
+      "@use-stellar/vue: no plugin installed. Call app.use(createStellarPlugin()) before using any composable."
+    );
+  }
+  return runtime;
+}
+function useQuery(options) {
+  const data = vue.shallowRef(null);
+  const loading = vue.ref(false);
+  const error = vue.shallowRef(null);
+  const updatedAt = vue.ref(null);
+  let observer = null;
+  let unsubscribe = null;
+  const resolved = vue.computed(() => ({
+    queryKey: options.queryKey(),
+    queryFn: options.queryFn,
+    store: options.store,
+    enabled: options.enabled?.() ?? true,
+    staleTime: vue.toValue(options.staleTime),
+    maxRetries: vue.toValue(options.maxRetries)
+  }));
+  function project(snapshot) {
+    data.value = snapshot.data;
+    loading.value = snapshot.loading;
+    error.value = snapshot.error;
+    updatedAt.value = snapshot.updatedAt;
+  }
+  function start() {
+    if (observer) return;
+    observer = core.createQueryObserver(resolved.value);
+    unsubscribe = observer.subscribe(project);
+    project(observer.getSnapshot());
+  }
+  vue.watch(
+    () => [
+      core.serializeKey(resolved.value.queryKey),
+      resolved.value.enabled,
+      resolved.value.staleTime,
+      resolved.value.maxRetries
+    ],
+    () => {
+      observer?.setOptions(resolved.value);
+      if (observer) project(observer.getSnapshot());
+    }
+    // Batched (the default "pre" flush), not "sync": inputs that change in
+    // the same tick — a contract id and a method, say — must produce one
+    // query for the final combination, not an extra request for every
+    // half-updated one in between.
+  );
+  if (vue.getCurrentInstance()) {
+    if (typeof globalThis.window === "undefined" && options.ssr) start();
+    else vue.onMounted(start);
+  } else {
+    start();
+  }
+  vue.onScopeDispose(() => {
+    unsubscribe?.();
+    observer?.destroy();
+    unsubscribe = null;
+    observer = null;
+  });
+  return {
+    data,
+    loading,
+    error,
+    updatedAt,
+    rateLimitedUntil: vue.computed(() => observer?.getRateLimitedUntil() ?? null),
+    refetch: () => observer?.fetch({ force: true }) ?? Promise.resolve()
+  };
+}
+
+// src/useBalance.ts
+function matchesAsset(balance, asset) {
+  if (asset === "XLM") return balance.asset === "XLM";
+  if (typeof asset !== "object") return balance.asset === asset;
+  return typeof balance.asset === "object" && balance.asset.code === asset.code && balance.asset.issuer === asset.issuer;
+}
+function useBalance(options) {
+  const runtime = useStellarRuntime();
+  const address = vue.computed(() => vue.toValue(options.address)?.trim() || null);
+  const asset = options.asset ?? "XLM";
+  const query = useQuery({
+    store: runtime.queryStore,
+    queryKey: () => core.accountKey(
+      runtime.networkConfig.horizonUrl,
+      runtime.networkConfig.network,
+      address.value ?? ""
+    ),
+    queryFn: () => core.fetchAccount(runtime.networkConfig, { address: address.value }),
+    enabled: () => address.value !== null,
+    staleTime: options.staleTime,
+    maxRetries: options.maxRetries
+  });
+  const balances = vue.computed(() => query.data.value?.balances ?? []);
+  return {
+    balance: vue.computed(
+      () => balances.value.find((item) => matchesAsset(item, asset))?.balance ?? null
+    ),
+    balances,
+    loading: vue.computed(() => query.loading.value),
+    error: vue.computed(() => query.error.value),
+    refetch: query.refetch
+  };
+}
+function unwrapArgs(value) {
+  if (!value) return [];
+  const raw = vue.toRaw(value);
+  return raw.map(
+    (argument) => argument !== null && typeof argument === "object" ? vue.toRaw(argument) : argument
+  );
+}
+function useSorobanContract(options) {
+  const { networkConfig, queryStore } = useStellarRuntime();
+  const call = vue.computed(() => {
+    const contractId = vue.toValue(options.contractId)?.trim() ?? "";
+    const method = vue.toValue(options.method)?.trim() ?? "";
+    if (!contractId || !method) return null;
+    const spec = options.spec === void 0 ? void 0 : vue.toValue(options.spec);
+    const sourceAccount = (options.sourceAccount === void 0 ? void 0 : vue.toValue(options.sourceAccount))?.trim() || core.ANONYMOUS_SIMULATION_SOURCE;
+    return {
+      contractId,
+      method,
+      args: unwrapArgs(options.args === void 0 ? [] : vue.toValue(options.args)),
+      spec: spec ? vue.toRaw(spec) : void 0,
+      sourceAccount
+    };
+  });
+  const query = useQuery({
+    store: queryStore,
+    queryKey: () => {
+      const current = call.value;
+      if (!current) return ["soroban", "disabled"];
+      return core.sorobanContractKey(
+        networkConfig.sorobanUrl,
+        networkConfig.network,
+        current.contractId,
+        current.method,
+        core.argsKey(current.args),
+        current.sourceAccount,
+        current.spec ? "spec" : "raw"
+      );
+    },
+    queryFn: () => core.simulateContractCall(networkConfig, call.value),
+    enabled: () => call.value !== null,
+    staleTime: options.staleTime
+  });
+  return {
+    data: vue.computed(() => query.data.value),
+    loading: vue.computed(() => query.loading.value),
+    error: vue.computed(
+      () => query.error.value ? core.toStellarError(query.error.value) : null
+    ),
+    refetch: () => {
+      void query.refetch();
+    }
+  };
+}
+function useContractEvents(options) {
+  const { networkConfig } = useStellarRuntime();
+  const events = vue.shallowRef([]);
+  const latestLedgerState = vue.ref(null);
+  const loadingState = vue.ref(false);
+  const errorState = vue.shallowRef(null);
+  let activePoller = null;
+  let activeUnsubscribe = null;
+  const input = vue.computed(() => {
+    const contractIds = [...vue.toValue(options.contractIds)];
+    const rawTopics = options.topics === void 0 ? void 0 : vue.toValue(options.topics);
+    const topics = rawTopics?.map((topic) => [...topic]);
+    return {
+      contractIds,
+      contractKey: JSON.stringify(contractIds),
+      topics,
+      topicKey: JSON.stringify(topics ?? []),
+      startLedger: options.startLedger === void 0 ? void 0 : vue.toValue(options.startLedger),
+      interval: (options.interval === void 0 ? void 0 : vue.toValue(options.interval)) ?? core.DEFAULT_POLL_INTERVAL,
+      bufferSize: (options.bufferSize === void 0 ? void 0 : vue.toValue(options.bufferSize)) ?? core.DEFAULT_BUFFER_SIZE,
+      enabled: (options.enabled === void 0 ? void 0 : vue.toValue(options.enabled)) ?? true
+    };
+  });
+  function stopActivePoller() {
+    activeUnsubscribe?.();
+    activeUnsubscribe = null;
+    activePoller?.stop();
+    activePoller = null;
+  }
+  vue.watch(
+    () => [
+      input.value.contractKey,
+      input.value.topicKey,
+      input.value.startLedger,
+      input.value.interval,
+      input.value.bufferSize,
+      input.value.enabled
+    ],
+    () => {
+      stopActivePoller();
+      const current = input.value;
+      if (!current.enabled || current.contractIds.length === 0) {
+        events.value = [];
+        latestLedgerState.value = null;
+        loadingState.value = false;
+        errorState.value = null;
+        return;
+      }
+      const poller = core.createContractEventPoller(
+        { sorobanUrl: networkConfig.sorobanUrl },
+        {
+          contractIds: current.contractIds,
+          topics: current.topics,
+          startLedger: current.startLedger,
+          interval: current.interval,
+          bufferSize: current.bufferSize
+        }
+      );
+      activePoller = poller;
+      activeUnsubscribe = poller.subscribe((snapshot) => {
+        events.value = snapshot.events;
+        latestLedgerState.value = snapshot.latestLedger;
+        loadingState.value = snapshot.loading;
+        errorState.value = snapshot.error;
+      });
+      poller.start();
+    },
+    { immediate: true }
+  );
+  vue.onScopeDispose(stopActivePoller);
+  const latestLedger = vue.computed(() => latestLedgerState.value);
+  const loading = vue.computed(() => loadingState.value);
+  const error = vue.computed(() => errorState.value);
+  function clear() {
+    activePoller?.clear();
+  }
+  return { events, latestLedger, loading, error, clear };
+}
+function useSendPayment() {
+  const runtime = useStellarRuntime();
+  const loading = vue.ref(false);
+  const error = vue.shallowRef(null);
+  const result = vue.shallowRef(null);
+  let operationId = 0;
+  let disposed = false;
+  const isCurrent = (id) => !disposed && id === operationId;
+  async function send(options) {
+    if (!core.onlineManager.isOnline()) throw core.offlineError();
+    const id = ++operationId;
+    const previousError = error.value;
+    const previousResult = result.value;
+    loading.value = true;
+    error.value = null;
+    result.value = null;
+    try {
+      const outcome = await core.sendPayment(
+        {
+          network: runtime.network,
+          networkConfig: runtime.networkConfig,
+          wallet: runtime.wallet,
+          queryStore: runtime.queryStore
+        },
+        options
+      );
+      if (isCurrent(id)) result.value = outcome;
+      return outcome;
+    } catch (caught) {
+      if (caught instanceof core.SendPaymentAbortedError) {
+        return { hash: "", status: "failed", error: caught.message };
+      }
+      if (core.isPreflightError(caught)) {
+        if (isCurrent(id)) {
+          error.value = previousError;
+          result.value = previousResult;
+        }
+        throw caught;
+      }
+      const stellarError = caught;
+      if (isCurrent(id)) {
+        if (stellarError.code === "TX_TIMEOUT") {
+          result.value = { hash: stellarError.hash ?? "", status: "pending" };
+        } else if (stellarError.isSubmissionFailure) {
+          result.value = { hash: stellarError.hash ?? "", status: "failed" };
+        }
+        error.value = stellarError;
+      }
+      throw caught;
+    } finally {
+      if (isCurrent(id)) loading.value = false;
+    }
+  }
+  function reset() {
+    operationId += 1;
+    loading.value = false;
+    error.value = null;
+    result.value = null;
+  }
+  vue.onScopeDispose(() => {
+    disposed = true;
+    operationId += 1;
+  });
+  return { send, loading, error, result, reset };
+}
+function useAddTrustline() {
+  const runtime = useStellarRuntime();
+  const loading = vue.ref(false);
+  const error = vue.shallowRef(null);
+  const result = vue.shallowRef(null);
+  let operationId = 0;
+  let disposed = false;
+  const isCurrent = (id) => !disposed && id === operationId;
+  async function addTrustline(options) {
+    if (!core.onlineManager.isOnline()) throw core.offlineError();
+    const id = ++operationId;
+    const previousError = error.value;
+    const previousResult = result.value;
+    loading.value = true;
+    error.value = null;
+    result.value = null;
+    try {
+      const outcome = await core.addTrustline(
+        {
+          network: runtime.network,
+          networkConfig: runtime.networkConfig,
+          wallet: runtime.wallet,
+          queryStore: runtime.queryStore
+        },
+        options
+      );
+      if (isCurrent(id)) result.value = outcome;
+      return outcome;
+    } catch (caught) {
+      if (caught instanceof core.AddTrustlineAbortedError) {
+        return { hash: "", status: "failed" };
+      }
+      if (core.isAddTrustlinePreflightError(caught)) {
+        if (isCurrent(id)) {
+          error.value = previousError;
+          result.value = previousResult;
+        }
+        throw caught;
+      }
+      const stellarError = caught;
+      if (isCurrent(id)) {
+        if (stellarError.code === "TX_TIMEOUT") {
+          result.value = { hash: stellarError.hash ?? "", status: "pending" };
+        } else if (stellarError.isSubmissionFailure) {
+          result.value = { hash: stellarError.hash ?? "", status: "failed" };
+        }
+        error.value = stellarError;
+      }
+      throw caught;
+    } finally {
+      if (isCurrent(id)) loading.value = false;
+    }
+  }
+  function reset() {
+    operationId += 1;
+    loading.value = false;
+    error.value = null;
+    result.value = null;
+  }
+  vue.onScopeDispose(() => {
+    disposed = true;
+    operationId += 1;
+  });
+  return { addTrustline, loading, error, result, reset };
+}
+function usePathPayment() {
+  const runtime = useStellarRuntime();
+  const loading = vue.ref(false);
+  const error = vue.shallowRef(null);
+  const result = vue.shallowRef(null);
+  let operationId = 0;
+  let disposed = false;
+  const isCurrent = (id) => !disposed && id === operationId;
+  async function pathPayment(options) {
+    if (!core.onlineManager.isOnline()) throw core.offlineError();
+    const id = ++operationId;
+    const previousError = error.value;
+    const previousResult = result.value;
+    loading.value = true;
+    error.value = null;
+    result.value = null;
+    try {
+      const outcome = await core.pathPayment(
+        {
+          network: runtime.network,
+          networkConfig: runtime.networkConfig,
+          wallet: runtime.wallet,
+          queryStore: runtime.queryStore
+        },
+        options
+      );
+      if (isCurrent(id)) result.value = outcome;
+      return outcome;
+    } catch (caught) {
+      if (core.isPathPaymentPreflightError(caught)) {
+        if (isCurrent(id)) {
+          error.value = previousError;
+          result.value = previousResult;
+        }
+        throw caught;
+      }
+      if (isCurrent(id)) error.value = caught;
+      throw caught;
+    } finally {
+      if (isCurrent(id)) loading.value = false;
+    }
+  }
+  function reset() {
+    operationId += 1;
+    loading.value = false;
+    error.value = null;
+    result.value = null;
+  }
+  vue.onScopeDispose(() => {
+    disposed = true;
+    operationId += 1;
+  });
+  return { pathPayment, loading, error, result, reset };
+}
+function useClaimableBalance(options = {}) {
+  const runtime = useStellarRuntime();
+  const address = vue.computed(() => {
+    const value = options.address === void 0 ? runtime.walletAddress.value : vue.toValue(options.address);
+    return value?.trim() || null;
+  });
+  const query = useQuery({
+    store: runtime.queryStore,
+    queryKey: () => core.claimableBalanceKey(
+      runtime.networkConfig.horizonUrl,
+      runtime.networkConfig.network,
+      address.value ?? ""
+    ),
+    queryFn: () => core.fetchClaimableBalances(runtime.networkConfig, { address: address.value }),
+    enabled: () => address.value !== null,
+    staleTime: options.staleTime
+  });
+  return {
+    balances: vue.computed(() => query.data.value ?? []),
+    loading: vue.computed(() => query.loading.value),
+    error: vue.computed(() => query.error.value),
+    refetch: query.refetch
+  };
+}
+function usePayments(options = {}) {
+  const runtime = useStellarRuntime();
+  const address = vue.computed(() => {
+    const value = options.address === void 0 ? runtime.walletAddress.value : vue.toValue(options.address);
+    return value?.trim() || null;
+  });
+  const limit = vue.computed(() => vue.toValue(options.limit) ?? 10);
+  const order = vue.computed(() => vue.toValue(options.order) ?? "desc");
+  const inputCursor = vue.computed(() => vue.toValue(options.cursor));
+  const activeCursor = vue.ref(inputCursor.value);
+  vue.watch(inputCursor, (cursor) => activeCursor.value = cursor, { flush: "sync" });
+  vue.watch(
+    [address, limit, order],
+    (_next, previous) => {
+      if (previous.length > 0) activeCursor.value = void 0;
+    },
+    { flush: "sync" }
+  );
+  const queryKey = vue.computed(
+    () => address.value ? core.paymentsKey(
+      runtime.networkConfig.horizonUrl,
+      runtime.networkConfig.network,
+      address.value,
+      limit.value,
+      order.value,
+      activeCursor.value
+    ) : ["payments", "disabled"]
+  );
+  const query = useQuery({
+    store: runtime.queryStore,
+    queryKey: () => queryKey.value,
+    queryFn: () => core.fetchPaymentsPage(runtime.networkConfig, {
+      address: address.value,
+      limit: limit.value,
+      order: order.value,
+      cursor: activeCursor.value
+    }),
+    enabled: () => address.value !== null,
+    maxRetries: options.maxRetries
+  });
+  const displayed = vue.shallowRef([]);
+  const nextPage = vue.shallowRef(null);
+  const prevPage = vue.shallowRef(null);
+  const pageHasNext = vue.ref(false);
+  const pageHasPrev = vue.ref(false);
+  const pageLoading = vue.ref(false);
+  const pageError = vue.shallowRef(null);
+  let requestId = 0;
+  function install(page) {
+    displayed.value = page.records;
+    nextPage.value = page.nextCursor;
+    prevPage.value = page.prevCursor;
+    pageHasNext.value = page.hasNext;
+    pageHasPrev.value = page.hasPrev;
+    pageError.value = null;
+  }
+  vue.watch(
+    query.data,
+    (page) => {
+      requestId += 1;
+      pageLoading.value = false;
+      if (page) install(page);
+      else {
+        displayed.value = [];
+        nextPage.value = null;
+        prevPage.value = null;
+        pageHasNext.value = false;
+        pageHasPrev.value = false;
+        pageError.value = null;
+      }
+    },
+    { immediate: true, flush: "sync" }
+  );
+  vue.watch(
+    () => core.serializeKey(queryKey.value),
+    () => {
+      requestId += 1;
+      displayed.value = [];
+      nextPage.value = null;
+      prevPage.value = null;
+      pageHasNext.value = false;
+      pageHasPrev.value = false;
+      pageLoading.value = false;
+      pageError.value = null;
+    },
+    { flush: "sync" }
+  );
+  async function navigate(direction) {
+    const load = direction === "next" ? nextPage.value : prevPage.value;
+    if (!load || !address.value) return;
+    const id = ++requestId;
+    pageLoading.value = true;
+    pageError.value = null;
+    try {
+      const response = await load();
+      if (id !== requestId || !address.value) return;
+      const hasMore = response.records.length > limit.value;
+      const records = hasMore ? response.records.slice(0, limit.value) : response.records;
+      const normalized = records.map((record) => core.normalizePayment(record, address.value));
+      if (normalized.length > 0) displayed.value = normalized;
+      nextPage.value = () => response.next();
+      prevPage.value = () => response.prev();
+      pageHasNext.value = direction === "next" ? hasMore : true;
+      pageHasPrev.value = direction === "prev" ? hasMore : true;
+    } catch (cause) {
+      if (id !== requestId) return;
+      pageError.value = core.toStellarError(cause);
+    } finally {
+      if (id === requestId) pageLoading.value = false;
+    }
+  }
+  async function refetch() {
+    requestId += 1;
+    pageError.value = null;
+    await query.refetch();
+  }
+  const error = vue.computed(() => pageError.value ?? query.error.value);
+  return {
+    payments: vue.computed(() => displayed.value),
+    loading: vue.computed(() => pageLoading.value || query.loading.value),
+    error,
+    isStale: vue.computed(() => error.value !== null && displayed.value.length > 0),
+    refetch,
+    fetchNext: () => navigate("next"),
+    fetchPrev: () => navigate("prev"),
+    hasNext: vue.computed(() => pageHasNext.value),
+    hasPrev: vue.computed(() => pageHasPrev.value)
+  };
+}
+function usePaymentHistory(options = {}) {
+  const payments = usePayments({
+    address: options.address,
+    limit: options.limit,
+    order: options.order,
+    cursor: options.cursor,
+    maxRetries: options.maxRetries
+  });
+  return {
+    ...payments,
+    payments: vue.computed(
+      () => core.filterPayments(payments.payments.value, {
+        direction: vue.toValue(options.direction) ?? "all",
+        asset: vue.toValue(options.asset) ?? "all"
+      })
+    )
+  };
+}
+function normalizeKey(key) {
+  return typeof key === "string" ? key : JSON.stringify(key);
+}
+var DEFAULT_STALE_TIME = 3e4;
+var DEFAULT_GC_TIME = 3e5;
+var VueQueryStore = class {
+  constructor(config = {}) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.entries = vue.reactive(/* @__PURE__ */ new Map());
+    this.staleTime = config.staleTime ?? DEFAULT_STALE_TIME;
+    this.gcTime = config.gcTime ?? DEFAULT_GC_TIME;
+  }
+  ensure(key) {
+    const existing = this.entries.get(key);
+    if (existing) return existing;
+    const entry = {
+      data: null,
+      updatedAt: null,
+      loading: false,
+      error: null,
+      promise: null,
+      subscribers: 0,
+      gcTimer: null
+    };
+    this.entries.set(key, entry);
+    return entry;
+  }
+  /**
+   * The live, reactive entry for a key. Read its fields inside a `computed`
+   * or `watchEffect` — Vue tracks the read and re-runs when the store writes
+   * to it.
+   */
+  getEntry(key) {
+    return this.ensure(key);
+  }
+  /**
+   * Registers a subscriber for `key` and cancels any pending GC eviction.
+   * Returns the unsubscribe function — call it from `onCleanup` /
+   * `onScopeDispose` so an idle entry is eventually evicted.
+   */
+  subscribe(key) {
+    const entry = this.ensure(key);
+    entry.subscribers += 1;
+    if (entry.gcTimer !== null) {
+      clearTimeout(entry.gcTimer);
+      entry.gcTimer = null;
+    }
+    return () => {
+      entry.subscribers = Math.max(0, entry.subscribers - 1);
+      if (entry.subscribers === 0) this.scheduleGc(key, entry);
+    };
+  }
+  /** Number of active subscribers for a key. Exposed for tests. */
+  subscriberCount(key) {
+    return this.entries.get(key)?.subscribers ?? 0;
+  }
+  scheduleGc(key, entry) {
+    if (this.gcTime === 0) {
+      this.entries.delete(key);
+      return;
+    }
+    entry.gcTimer = setTimeout(() => {
+      if (entry.subscribers === 0) this.entries.delete(key);
+    }, this.gcTime);
+  }
+  isFresh(key, staleTime) {
+    const entry = this.entries.get(key);
+    if (!entry?.updatedAt) return false;
+    return Date.now() - entry.updatedAt < (staleTime ?? this.staleTime);
+  }
+  /**
+   * Runs `queryFn` for `key`, deduplicated: a call made while a fetch for the
+   * same key is already in flight awaits that same promise instead of
+   * issuing a second request — this is what lets two Vue scopes reading the
+   * same query share one network call. Skipped entirely when cached data is
+   * still within `staleTime`, unless `force` is set.
+   */
+  run(key, queryFn, opts = {}) {
+    const entry = this.ensure(key);
+    if (!opts.force) {
+      if (entry.promise) return entry.promise;
+      if (entry.data !== null && this.isFresh(key, opts.staleTime)) {
+        return Promise.resolve(entry.data);
+      }
+    }
+    entry.loading = true;
+    entry.error = null;
+    const promise = queryFn().then(
+      (data) => {
+        entry.data = data;
+        entry.updatedAt = Date.now();
+        entry.loading = false;
+        entry.error = null;
+        entry.promise = null;
+        return data;
+      },
+      (err) => {
+        entry.loading = false;
+        entry.error = err;
+        entry.promise = null;
+        throw err;
+      }
+    );
+    entry.promise = promise;
+    return promise;
+  }
+  /** Marks a cached query stale so its next read fetches fresh data. */
+  invalidate(key) {
+    const entry = this.entries.get(normalizeKey(key));
+    if (entry) entry.updatedAt = null;
+  }
+  /** Empties the store. Useful in tests; not meant for app code. */
+  clear() {
+    for (const entry of this.entries.values()) {
+      if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
+    }
+    this.entries.clear();
+  }
+};
+
+Object.defineProperty(exports, "ANONYMOUS_SIMULATION_SOURCE", {
+  enumerable: true,
+  get: function () { return core.ANONYMOUS_SIMULATION_SOURCE; }
+});
+Object.defineProperty(exports, "accountKey", {
+  enumerable: true,
+  get: function () { return core.accountKey; }
+});
+Object.defineProperty(exports, "claimableBalanceKey", {
+  enumerable: true,
+  get: function () { return core.claimableBalanceKey; }
+});
+Object.defineProperty(exports, "paymentsKey", {
+  enumerable: true,
+  get: function () { return core.paymentsKey; }
+});
+exports.NETWORK_CONFIGS = NETWORK_CONFIGS;
+exports.STELLAR_RUNTIME_KEY = STELLAR_RUNTIME_KEY;
+exports.VueQueryStore = VueQueryStore;
+exports.createStellarPlugin = createStellarPlugin;
+exports.createStellarRuntime = createStellarRuntime;
+exports.useAddTrustline = useAddTrustline;
+exports.useBalance = useBalance;
+exports.useClaimableBalance = useClaimableBalance;
+exports.useContractEvents = useContractEvents;
+exports.usePathPayment = usePathPayment;
+exports.usePaymentHistory = usePaymentHistory;
+exports.usePayments = usePayments;
+exports.useSendPayment = useSendPayment;
+exports.useSorobanContract = useSorobanContract;
+exports.useStellarRuntime = useStellarRuntime;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map