@use-stellar/vue 0.0.0-stage → 0.2.3

package/dist/index.mjs

@@ -0,0 +1,713 @@
+import { useStellarRuntime } from './chunk-7ROX7ZPL.mjs';
+export { NETWORK_CONFIGS, STELLAR_RUNTIME_KEY, createStellarPlugin, createStellarRuntime, useStellarRuntime } from './chunk-7ROX7ZPL.mjs';
+import { computed, toValue, toRaw, shallowRef, ref, watch, onScopeDispose, reactive, getCurrentInstance, onMounted } from 'vue';
+import { ANONYMOUS_SIMULATION_SOURCE, toStellarError, DEFAULT_BUFFER_SIZE, DEFAULT_POLL_INTERVAL, createContractEventPoller, paymentsKey, serializeKey, filterPayments, onlineManager, offlineError, addTrustline, AddTrustlineAbortedError, isAddTrustlinePreflightError, pathPayment, isPathPaymentPreflightError, normalizePayment, sendPayment, SendPaymentAbortedError, isPreflightError, fetchAccount, accountKey, simulateContractCall, sorobanContractKey, argsKey, fetchClaimableBalances, claimableBalanceKey, fetchPaymentsPage, createQueryObserver } from 'use-stellar/core';
+export { ANONYMOUS_SIMULATION_SOURCE, accountKey, claimableBalanceKey, paymentsKey } from 'use-stellar/core';
+
+function useQuery(options) {
+  const data = shallowRef(null);
+  const loading = ref(false);
+  const error = shallowRef(null);
+  const updatedAt = ref(null);
+  let observer = null;
+  let unsubscribe = null;
+  const resolved = computed(() => ({
+    queryKey: options.queryKey(),
+    queryFn: options.queryFn,
+    store: options.store,
+    enabled: options.enabled?.() ?? true,
+    staleTime: toValue(options.staleTime),
+    maxRetries: 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 = createQueryObserver(resolved.value);
+    unsubscribe = observer.subscribe(project);
+    project(observer.getSnapshot());
+  }
+  watch(
+    () => [
+      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 (getCurrentInstance()) {
+    if (typeof globalThis.window === "undefined" && options.ssr) start();
+    else onMounted(start);
+  } else {
+    start();
+  }
+  onScopeDispose(() => {
+    unsubscribe?.();
+    observer?.destroy();
+    unsubscribe = null;
+    observer = null;
+  });
+  return {
+    data,
+    loading,
+    error,
+    updatedAt,
+    rateLimitedUntil: 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 = computed(() => toValue(options.address)?.trim() || null);
+  const asset = options.asset ?? "XLM";
+  const query = useQuery({
+    store: runtime.queryStore,
+    queryKey: () => accountKey(
+      runtime.networkConfig.horizonUrl,
+      runtime.networkConfig.network,
+      address.value ?? ""
+    ),
+    queryFn: () => fetchAccount(runtime.networkConfig, { address: address.value }),
+    enabled: () => address.value !== null,
+    staleTime: options.staleTime,
+    maxRetries: options.maxRetries
+  });
+  const balances = computed(() => query.data.value?.balances ?? []);
+  return {
+    balance: computed(
+      () => balances.value.find((item) => matchesAsset(item, asset))?.balance ?? null
+    ),
+    balances,
+    loading: computed(() => query.loading.value),
+    error: computed(() => query.error.value),
+    refetch: query.refetch
+  };
+}
+function unwrapArgs(value) {
+  if (!value) return [];
+  const raw = toRaw(value);
+  return raw.map(
+    (argument) => argument !== null && typeof argument === "object" ? toRaw(argument) : argument
+  );
+}
+function useSorobanContract(options) {
+  const { networkConfig, queryStore } = useStellarRuntime();
+  const call = computed(() => {
+    const contractId = toValue(options.contractId)?.trim() ?? "";
+    const method = toValue(options.method)?.trim() ?? "";
+    if (!contractId || !method) return null;
+    const spec = options.spec === void 0 ? void 0 : toValue(options.spec);
+    const sourceAccount = (options.sourceAccount === void 0 ? void 0 : toValue(options.sourceAccount))?.trim() || ANONYMOUS_SIMULATION_SOURCE;
+    return {
+      contractId,
+      method,
+      args: unwrapArgs(options.args === void 0 ? [] : toValue(options.args)),
+      spec: spec ? toRaw(spec) : void 0,
+      sourceAccount
+    };
+  });
+  const query = useQuery({
+    store: queryStore,
+    queryKey: () => {
+      const current = call.value;
+      if (!current) return ["soroban", "disabled"];
+      return sorobanContractKey(
+        networkConfig.sorobanUrl,
+        networkConfig.network,
+        current.contractId,
+        current.method,
+        argsKey(current.args),
+        current.sourceAccount,
+        current.spec ? "spec" : "raw"
+      );
+    },
+    queryFn: () => simulateContractCall(networkConfig, call.value),
+    enabled: () => call.value !== null,
+    staleTime: options.staleTime
+  });
+  return {
+    data: computed(() => query.data.value),
+    loading: computed(() => query.loading.value),
+    error: computed(
+      () => query.error.value ? toStellarError(query.error.value) : null
+    ),
+    refetch: () => {
+      void query.refetch();
+    }
+  };
+}
+function useContractEvents(options) {
+  const { networkConfig } = useStellarRuntime();
+  const events = shallowRef([]);
+  const latestLedgerState = ref(null);
+  const loadingState = ref(false);
+  const errorState = shallowRef(null);
+  let activePoller = null;
+  let activeUnsubscribe = null;
+  const input = computed(() => {
+    const contractIds = [...toValue(options.contractIds)];
+    const rawTopics = options.topics === void 0 ? void 0 : 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 : toValue(options.startLedger),
+      interval: (options.interval === void 0 ? void 0 : toValue(options.interval)) ?? DEFAULT_POLL_INTERVAL,
+      bufferSize: (options.bufferSize === void 0 ? void 0 : toValue(options.bufferSize)) ?? DEFAULT_BUFFER_SIZE,
+      enabled: (options.enabled === void 0 ? void 0 : toValue(options.enabled)) ?? true
+    };
+  });
+  function stopActivePoller() {
+    activeUnsubscribe?.();
+    activeUnsubscribe = null;
+    activePoller?.stop();
+    activePoller = null;
+  }
+  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 = 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 }
+  );
+  onScopeDispose(stopActivePoller);
+  const latestLedger = computed(() => latestLedgerState.value);
+  const loading = computed(() => loadingState.value);
+  const error = computed(() => errorState.value);
+  function clear() {
+    activePoller?.clear();
+  }
+  return { events, latestLedger, loading, error, clear };
+}
+function useSendPayment() {
+  const runtime = useStellarRuntime();
+  const loading = ref(false);
+  const error = shallowRef(null);
+  const result = shallowRef(null);
+  let operationId = 0;
+  let disposed = false;
+  const isCurrent = (id) => !disposed && id === operationId;
+  async function send(options) {
+    if (!onlineManager.isOnline()) throw 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 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 SendPaymentAbortedError) {
+        return { hash: "", status: "failed", error: caught.message };
+      }
+      if (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;
+  }
+  onScopeDispose(() => {
+    disposed = true;
+    operationId += 1;
+  });
+  return { send, loading, error, result, reset };
+}
+function useAddTrustline() {
+  const runtime = useStellarRuntime();
+  const loading = ref(false);
+  const error = shallowRef(null);
+  const result = shallowRef(null);
+  let operationId = 0;
+  let disposed = false;
+  const isCurrent = (id) => !disposed && id === operationId;
+  async function addTrustline$1(options) {
+    if (!onlineManager.isOnline()) throw 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 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 AddTrustlineAbortedError) {
+        return { hash: "", status: "failed" };
+      }
+      if (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;
+  }
+  onScopeDispose(() => {
+    disposed = true;
+    operationId += 1;
+  });
+  return { addTrustline: addTrustline$1, loading, error, result, reset };
+}
+function usePathPayment() {
+  const runtime = useStellarRuntime();
+  const loading = ref(false);
+  const error = shallowRef(null);
+  const result = shallowRef(null);
+  let operationId = 0;
+  let disposed = false;
+  const isCurrent = (id) => !disposed && id === operationId;
+  async function pathPayment$1(options) {
+    if (!onlineManager.isOnline()) throw 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 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 (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;
+  }
+  onScopeDispose(() => {
+    disposed = true;
+    operationId += 1;
+  });
+  return { pathPayment: pathPayment$1, loading, error, result, reset };
+}
+function useClaimableBalance(options = {}) {
+  const runtime = useStellarRuntime();
+  const address = computed(() => {
+    const value = options.address === void 0 ? runtime.walletAddress.value : toValue(options.address);
+    return value?.trim() || null;
+  });
+  const query = useQuery({
+    store: runtime.queryStore,
+    queryKey: () => claimableBalanceKey(
+      runtime.networkConfig.horizonUrl,
+      runtime.networkConfig.network,
+      address.value ?? ""
+    ),
+    queryFn: () => fetchClaimableBalances(runtime.networkConfig, { address: address.value }),
+    enabled: () => address.value !== null,
+    staleTime: options.staleTime
+  });
+  return {
+    balances: computed(() => query.data.value ?? []),
+    loading: computed(() => query.loading.value),
+    error: computed(() => query.error.value),
+    refetch: query.refetch
+  };
+}
+function usePayments(options = {}) {
+  const runtime = useStellarRuntime();
+  const address = computed(() => {
+    const value = options.address === void 0 ? runtime.walletAddress.value : toValue(options.address);
+    return value?.trim() || null;
+  });
+  const limit = computed(() => toValue(options.limit) ?? 10);
+  const order = computed(() => toValue(options.order) ?? "desc");
+  const inputCursor = computed(() => toValue(options.cursor));
+  const activeCursor = ref(inputCursor.value);
+  watch(inputCursor, (cursor) => activeCursor.value = cursor, { flush: "sync" });
+  watch(
+    [address, limit, order],
+    (_next, previous) => {
+      if (previous.length > 0) activeCursor.value = void 0;
+    },
+    { flush: "sync" }
+  );
+  const queryKey = computed(
+    () => address.value ? 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: () => fetchPaymentsPage(runtime.networkConfig, {
+      address: address.value,
+      limit: limit.value,
+      order: order.value,
+      cursor: activeCursor.value
+    }),
+    enabled: () => address.value !== null,
+    maxRetries: options.maxRetries
+  });
+  const displayed = shallowRef([]);
+  const nextPage = shallowRef(null);
+  const prevPage = shallowRef(null);
+  const pageHasNext = ref(false);
+  const pageHasPrev = ref(false);
+  const pageLoading = ref(false);
+  const pageError = 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;
+  }
+  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" }
+  );
+  watch(
+    () => 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) => 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 = toStellarError(cause);
+    } finally {
+      if (id === requestId) pageLoading.value = false;
+    }
+  }
+  async function refetch() {
+    requestId += 1;
+    pageError.value = null;
+    await query.refetch();
+  }
+  const error = computed(() => pageError.value ?? query.error.value);
+  return {
+    payments: computed(() => displayed.value),
+    loading: computed(() => pageLoading.value || query.loading.value),
+    error,
+    isStale: computed(() => error.value !== null && displayed.value.length > 0),
+    refetch,
+    fetchNext: () => navigate("next"),
+    fetchPrev: () => navigate("prev"),
+    hasNext: computed(() => pageHasNext.value),
+    hasPrev: 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: computed(
+      () => filterPayments(payments.payments.value, {
+        direction: toValue(options.direction) ?? "all",
+        asset: 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 = 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();
+  }
+};
+
+export { VueQueryStore, useAddTrustline, useBalance, useClaimableBalance, useContractEvents, usePathPayment, usePaymentHistory, usePayments, useSendPayment, useSorobanContract };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map