astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es21.js

@@ -0,0 +1,272 @@
+import { proxyMap as w, subscribeKey as k } from "./astra-sdk.es442.js";
+import { proxy as N, subscribe as l, ref as d } from "./astra-sdk.es441.js";
+import { AccountController as C } from "./astra-sdk.es20.js";
+import { PublicStateController as p } from "./astra-sdk.es31.js";
+import "./astra-sdk.es14.js";
+import { NetworkUtil as v } from "./astra-sdk.es225.js";
+import "./astra-sdk.es15.js";
+import { CoreHelperUtil as m } from "./astra-sdk.es58.js";
+import { ConstantsUtil as h } from "./astra-sdk.es224.js";
+import { ModalController as A } from "./astra-sdk.es18.js";
+import { EventsController as S } from "./astra-sdk.es32.js";
+import { RouterController as g } from "./astra-sdk.es19.js";
+import { StorageUtil as u } from "./astra-sdk.es349.js";
+const I = {
+  currentTab: 0,
+  tokenBalance: [],
+  smartAccountDeployed: !1,
+  addressLabels: /* @__PURE__ */ new Map(),
+  allAccounts: []
+}, E = {
+  supportsAllNetworks: !0,
+  smartAccountEnabledNetworks: []
+}, o = N({
+  chains: w(),
+  activeCaipAddress: void 0,
+  activeChain: void 0,
+  activeCaipNetwork: void 0,
+  noAdapters: !1,
+  universalAdapter: {
+    networkControllerClient: void 0,
+    connectionControllerClient: void 0
+  }
+}), f = {
+  state: o,
+  subscribe(e) {
+    return l(o, () => {
+      e(o);
+    });
+  },
+  subscribeKey(e, t) {
+    return k(o, e, t);
+  },
+  subscribeChainProp(e, t, n) {
+    let r;
+    return l(o.chains, () => {
+      var c;
+      const i = n || o.activeChain;
+      if (i) {
+        const s = (c = o.chains.get(i)) == null ? void 0 : c[e];
+        r !== s && (r = s, t(s));
+      }
+    });
+  },
+  initialize(e, t) {
+    const { chainId: n, namespace: r } = u.getActiveNetworkProps(), i = t == null ? void 0 : t.find((a) => a.id.toString() === (n == null ? void 0 : n.toString())), s = e.find((a) => (a == null ? void 0 : a.namespace) === r) || (e == null ? void 0 : e[0]);
+    ((e == null ? void 0 : e.length) === 0 || !s) && (o.noAdapters = !0), o.noAdapters || (o.activeChain = s == null ? void 0 : s.namespace, o.activeCaipNetwork = i, o.activeChain && p.set({ activeChain: s == null ? void 0 : s.namespace }), e.forEach((a) => {
+      o.chains.set(a.namespace, {
+        namespace: a.namespace,
+        connectionControllerClient: a.connectionControllerClient,
+        networkControllerClient: a.networkControllerClient,
+        adapterType: a.adapterType,
+        accountState: I,
+        networkState: E,
+        caipNetworks: a.caipNetworks
+      });
+    }));
+  },
+  setAdapterNetworkState(e, t) {
+    const n = o.chains.get(e);
+    n && (n.networkState = d({
+      ...n.networkState,
+      ...t
+    }), o.chains.set(e, d(n)));
+  },
+  setChainAccountData(e, t, n = !0) {
+    if (!e)
+      throw new Error("Chain is required to update chain account data");
+    const r = o.chains.get(e);
+    r && (r.accountState = d({
+      ...r.accountState,
+      ...t
+    }), o.chains.set(e, r), (o.chains.size === 1 || o.activeChain === e) && (t.caipAddress && (o.activeCaipAddress = t.caipAddress), C.replaceState(r.accountState)));
+  },
+  // eslint-disable-next-line max-params
+  setAccountProp(e, t, n, r = !0) {
+    this.setChainAccountData(n, {
+      [e]: t
+    }, r);
+  },
+  setActiveNamespace(e) {
+    var r, i;
+    o.activeChain = e;
+    const t = e ? o.chains.get(e) : void 0, n = (r = t == null ? void 0 : t.networkState) == null ? void 0 : r.caipNetwork;
+    n != null && n.id && e && (o.activeCaipAddress = (i = t == null ? void 0 : t.accountState) == null ? void 0 : i.caipAddress, o.activeCaipNetwork = n, u.setActiveCaipNetworkId(n == null ? void 0 : n.caipNetworkId), p.set({
+      activeChain: e,
+      selectedNetworkId: n == null ? void 0 : n.caipNetworkId
+    }));
+  },
+  setActiveCaipNetwork(e) {
+    var r, i, c;
+    if (!e)
+      return;
+    const t = o.chains.get(e.chainNamespace);
+    o.activeChain = e.chainNamespace, o.activeCaipNetwork = e, (r = t == null ? void 0 : t.accountState) != null && r.address ? o.activeCaipAddress = `${e.chainNamespace}:${e.id}:${(i = t == null ? void 0 : t.accountState) == null ? void 0 : i.address}` : o.activeCaipAddress = void 0, t && C.replaceState(t.accountState), p.set({
+      activeChain: o.activeChain,
+      selectedNetworkId: (c = o.activeCaipNetwork) == null ? void 0 : c.caipNetworkId
+    }), u.setActiveCaipNetworkId(e.caipNetworkId), this.checkIfSupportedNetwork(e.chainNamespace) || this.showUnsupportedChainUI();
+  },
+  addCaipNetwork(e) {
+    var n;
+    if (!e)
+      return;
+    const t = o.chains.get(e.chainNamespace);
+    t && ((n = t == null ? void 0 : t.caipNetworks) == null || n.push(e));
+  },
+  async switchActiveNetwork(e) {
+    var i;
+    const t = f.state.chains.get(f.state.activeChain), n = !((i = t == null ? void 0 : t.caipNetworks) != null && i.some((c) => {
+      var s;
+      return c.id === ((s = o.activeCaipNetwork) == null ? void 0 : s.id);
+    })), r = this.getNetworkControllerClient(e.chainNamespace);
+    r && await r.switchCaipNetwork(e), n && g.goBack(), this.setActiveCaipNetwork(e), e && S.sendEvent({
+      type: "track",
+      event: "SWITCH_NETWORK",
+      properties: { network: e.caipNetworkId }
+    });
+  },
+  setActiveConnector(e) {
+    e && (o.activeConnector = d(e));
+  },
+  getNetworkControllerClient(e) {
+    const t = e || o.activeChain, n = o.chains.get(t);
+    if (!n)
+      throw new Error("Chain adapter not found");
+    if (!n.networkControllerClient)
+      throw new Error("NetworkController client not set");
+    return n.networkControllerClient;
+  },
+  getConnectionControllerClient(e) {
+    const t = e || o.activeChain;
+    if (!t)
+      throw new Error("Chain is required to get connection controller client");
+    const n = o.chains.get(t);
+    if (!(n != null && n.connectionControllerClient))
+      throw new Error("ConnectionController client not set");
+    return n.connectionControllerClient;
+  },
+  getAccountProp(e, t) {
+    var i;
+    let n = o.activeChain;
+    if (t && (n = t), !n)
+      return;
+    const r = (i = o.chains.get(n)) == null ? void 0 : i.accountState;
+    if (r)
+      return r[e];
+  },
+  getNetworkProp(e, t) {
+    var r;
+    const n = (r = o.chains.get(t)) == null ? void 0 : r.networkState;
+    if (n)
+      return n[e];
+  },
+  getRequestedCaipNetworks(e) {
+    const t = o.chains.get(e), { approvedCaipNetworkIds: n = [], requestedCaipNetworks: r = [] } = (t == null ? void 0 : t.networkState) || {};
+    return m.sortRequestedNetworks(n, r);
+  },
+  getAllRequestedCaipNetworks() {
+    const e = [];
+    return o.chains.forEach((t) => {
+      const n = this.getRequestedCaipNetworks(t.namespace);
+      e.push(...n);
+    }), e;
+  },
+  setRequestedCaipNetworks(e, t) {
+    this.setAdapterNetworkState(t, { requestedCaipNetworks: e });
+  },
+  getAllApprovedCaipNetworkIds() {
+    const e = [];
+    return o.chains.forEach((t) => {
+      const n = this.getApprovedCaipNetworkIds(t.namespace);
+      e.push(...n);
+    }), e;
+  },
+  getActiveCaipNetwork() {
+    return o.activeCaipNetwork;
+  },
+  getActiveCaipAddress() {
+    return o.activeCaipAddress;
+  },
+  getApprovedCaipNetworkIds(e) {
+    var r;
+    const t = o.chains.get(e);
+    return ((r = t == null ? void 0 : t.networkState) == null ? void 0 : r.approvedCaipNetworkIds) || [];
+  },
+  async setApprovedCaipNetworksData(e) {
+    const t = this.getNetworkControllerClient(), n = await (t == null ? void 0 : t.getApprovedCaipNetworksData());
+    this.setAdapterNetworkState(e, {
+      approvedCaipNetworkIds: n == null ? void 0 : n.approvedCaipNetworkIds,
+      supportsAllNetworks: n == null ? void 0 : n.supportsAllNetworks
+    });
+  },
+  checkIfSupportedNetwork(e) {
+    const t = this.state.activeCaipNetwork, n = this.getRequestedCaipNetworks(e);
+    return n.length ? n == null ? void 0 : n.some((r) => r.id === (t == null ? void 0 : t.id)) : !0;
+  },
+  checkIfSupportedChainId(e) {
+    if (!this.state.activeChain)
+      return !0;
+    const t = this.getRequestedCaipNetworks(this.state.activeChain);
+    return t == null ? void 0 : t.some((n) => n.id === e);
+  },
+  // Smart Account Network Handlers
+  setSmartAccountEnabledNetworks(e, t) {
+    this.setAdapterNetworkState(t, { smartAccountEnabledNetworks: e });
+  },
+  checkIfSmartAccountEnabled() {
+    var r;
+    const e = v.caipNetworkIdToNumber((r = o.activeCaipNetwork) == null ? void 0 : r.caipNetworkId), t = this.state.activeChain;
+    if (!t || !e)
+      return !1;
+    const n = this.getNetworkProp("smartAccountEnabledNetworks", t);
+    return !!(n != null && n.includes(Number(e)));
+  },
+  getActiveNetworkTokenAddress() {
+    var r, i;
+    const e = ((r = this.state.activeCaipNetwork) == null ? void 0 : r.chainNamespace) || "eip155", t = ((i = this.state.activeCaipNetwork) == null ? void 0 : i.id) || 1, n = h.NATIVE_TOKEN_ADDRESS[e];
+    return `${e}:${t}:${n}`;
+  },
+  showUnsupportedChainUI() {
+    setTimeout(() => {
+      A.open({ view: "UnsupportedChain" });
+    }, 300);
+  },
+  checkIfNamesSupported() {
+    const e = o.activeCaipNetwork;
+    return !!(e != null && e.chainNamespace && h.NAMES_SUPPORTED_CHAIN_NAMESPACES.includes(e.chainNamespace));
+  },
+  resetNetwork(e) {
+    this.setAdapterNetworkState(e, {
+      approvedCaipNetworkIds: void 0,
+      supportsAllNetworks: !0,
+      smartAccountEnabledNetworks: []
+    });
+  },
+  resetAccount(e) {
+    const t = e;
+    if (!t)
+      throw new Error("Chain is required to set account prop");
+    this.state.activeCaipAddress = void 0, this.setChainAccountData(t, d({
+      smartAccountDeployed: !1,
+      currentTab: 0,
+      caipAddress: void 0,
+      address: void 0,
+      balance: void 0,
+      balanceSymbol: void 0,
+      profileName: void 0,
+      profileImage: void 0,
+      addressExplorerUrl: void 0,
+      tokenBalance: [],
+      connectedWalletInfo: void 0,
+      preferredAccountType: void 0,
+      socialProvider: void 0,
+      socialWindow: void 0,
+      farcasterUrl: void 0,
+      provider: void 0,
+      allAccounts: []
+    }));
+  }
+};
+export {
+  f as ChainController
+};

package/dist/astra-sdk.es210.js

@@ -0,0 +1,17 @@
+import { useMutation as s } from "./astra-sdk.es199.js";
+import { useConfig as e } from "./astra-sdk.es184.js";
+import { writeContractMutationOptions as m } from "./astra-sdk.es211.js";
+function C(t = {}) {
+  const { mutation: o } = t, n = e(t), i = m(n), { mutate: r, mutateAsync: c, ...u } = s({
+    ...o,
+    ...i
+  });
+  return {
+    ...u,
+    writeContract: r,
+    writeContractAsync: c
+  };
+}
+export {
+  C as useWriteContract
+};

package/dist/astra-sdk.es211.js

@@ -0,0 +1,12 @@
+import { writeContract as n } from "./astra-sdk.es327.js";
+function i(t) {
+  return {
+    mutationFn(r) {
+      return n(t, r);
+    },
+    mutationKey: ["writeContract"]
+  };
+}
+export {
+  i as writeContractMutationOptions
+};

package/dist/astra-sdk.es212.js

@@ -0,0 +1,37 @@
+import { reconnect as h } from "./astra-sdk.es334.js";
+function _(n, p) {
+  const { initialState: r, reconnectOnMount: s } = p;
+  return r && !n._internal.store.persist.hasHydrated() && n.setState({
+    ...r,
+    chainId: n.chains.some((e) => e.id === r.chainId) ? r.chainId : n.chains[0].id,
+    connections: s ? r.connections : /* @__PURE__ */ new Map(),
+    status: s ? "reconnecting" : "disconnected"
+  }), {
+    async onMount() {
+      n._internal.ssr && (await n._internal.store.persist.rehydrate(), n._internal.mipd && n._internal.connectors.setState((e) => {
+        var d;
+        const i = /* @__PURE__ */ new Set();
+        for (const t of e ?? [])
+          if (t.rdns) {
+            const o = Array.isArray(t.rdns) ? t.rdns : [t.rdns];
+            for (const a of o)
+              i.add(a);
+          }
+        const c = [], l = ((d = n._internal.mipd) == null ? void 0 : d.getProviders()) ?? [];
+        for (const t of l) {
+          if (i.has(t.info.rdns))
+            continue;
+          const o = n._internal.connectors.providerDetailToConnector(t), a = n._internal.connectors.setup(o);
+          c.push(a);
+        }
+        return [...e, ...c];
+      })), s ? h(n) : n.storage && n.setState((e) => ({
+        ...e,
+        connections: /* @__PURE__ */ new Map()
+      }));
+    }
+  };
+}
+export {
+  _ as hydrate
+};

package/dist/astra-sdk.es213.js

@@ -0,0 +1,4 @@
+const o = "2.14.0";
+export {
+  o as version
+};

package/dist/astra-sdk.es214.js

@@ -0,0 +1,8 @@
+import { QueryObserver as e } from "./astra-sdk.es215.js";
+import { useBaseQuery as u } from "./astra-sdk.es216.js";
+function m(r, o) {
+  return u(r, e);
+}
+export {
+  m as useQuery
+};

package/dist/astra-sdk.es215.js

@@ -0,0 +1,308 @@
+var ot = (i) => {
+  throw TypeError(i);
+};
+var V = (i, t, s) => t.has(i) || ot("Cannot " + s);
+var e = (i, t, s) => (V(i, t, "read from private field"), s ? s.call(i) : t.get(i)), u = (i, t, s) => t.has(i) ? ot("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(i) : t.set(i, s), h = (i, t, s, n) => (V(i, t, "write to private field"), n ? n.call(i, s) : t.set(i, s), s), c = (i, t, s) => (V(i, t, "access private method"), s);
+import { focusManager as gt } from "./astra-sdk.es428.js";
+import { notifyManager as Rt } from "./astra-sdk.es219.js";
+import { fetchState as yt } from "./astra-sdk.es433.js";
+import { Subscribable as vt } from "./astra-sdk.es434.js";
+import { pendingThenable as ct } from "./astra-sdk.es430.js";
+import { resolveEnabled as v, shallowEqualObjects as K, resolveStaleTime as z, noop as Ot, isServer as lt, isValidTimeout as ut, timeUntilStale as St, replaceData as dt } from "./astra-sdk.es431.js";
+var p, r, j, f, U, D, O, y, A, x, L, w, E, S, M, a, P, G, J, X, Y, Z, $, q, mt, bt, Lt = (bt = class extends vt {
+  constructor(t, s) {
+    super();
+    u(this, a);
+    u(this, p);
+    u(this, r);
+    u(this, j);
+    u(this, f);
+    u(this, U);
+    u(this, D);
+    u(this, O);
+    u(this, y);
+    u(this, A);
+    u(this, x);
+    // This property keeps track of the last query with defined data.
+    // It will be used to pass the previous data and query to the placeholder function between renders.
+    u(this, L);
+    u(this, w);
+    u(this, E);
+    u(this, S);
+    u(this, M, /* @__PURE__ */ new Set());
+    this.options = s, h(this, p, t), h(this, y, null), h(this, O, ct()), this.options.experimental_prefetchInRender || e(this, O).reject(
+      new Error("experimental_prefetchInRender feature flag is not enabled")
+    ), this.bindMethods(), this.setOptions(s);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (e(this, r).addObserver(this), ft(e(this, r), this.options) ? c(this, a, P).call(this) : this.updateResult(), c(this, a, Y).call(this));
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return tt(
+      e(this, r),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return tt(
+      e(this, r),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), c(this, a, Z).call(this), c(this, a, $).call(this), e(this, r).removeObserver(this);
+  }
+  setOptions(t, s) {
+    const n = this.options, b = e(this, r);
+    if (this.options = e(this, p).defaultQueryOptions(t), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof v(this.options.enabled, e(this, r)) != "boolean")
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    c(this, a, q).call(this), e(this, r).setOptions(this.options), n._defaulted && !K(this.options, n) && e(this, p).getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: e(this, r),
+      observer: this
+    });
+    const l = this.hasListeners();
+    l && pt(
+      e(this, r),
+      b,
+      this.options,
+      n
+    ) && c(this, a, P).call(this), this.updateResult(s), l && (e(this, r) !== b || v(this.options.enabled, e(this, r)) !== v(n.enabled, e(this, r)) || z(this.options.staleTime, e(this, r)) !== z(n.staleTime, e(this, r))) && c(this, a, G).call(this);
+    const g = c(this, a, J).call(this);
+    l && (e(this, r) !== b || v(this.options.enabled, e(this, r)) !== v(n.enabled, e(this, r)) || g !== e(this, S)) && c(this, a, X).call(this, g);
+  }
+  getOptimisticResult(t) {
+    const s = e(this, p).getQueryCache().build(e(this, p), t), n = this.createResult(s, t);
+    return It(this, n) && (h(this, f, n), h(this, D, this.options), h(this, U, e(this, r).state)), n;
+  }
+  getCurrentResult() {
+    return e(this, f);
+  }
+  trackResult(t, s) {
+    const n = {};
+    return Object.keys(t).forEach((b) => {
+      Object.defineProperty(n, b, {
+        configurable: !1,
+        enumerable: !0,
+        get: () => (this.trackProp(b), s == null || s(b), t[b])
+      });
+    }), n;
+  }
+  trackProp(t) {
+    e(this, M).add(t);
+  }
+  getCurrentQuery() {
+    return e(this, r);
+  }
+  refetch({ ...t } = {}) {
+    return this.fetch({
+      ...t
+    });
+  }
+  fetchOptimistic(t) {
+    const s = e(this, p).defaultQueryOptions(t), n = e(this, p).getQueryCache().build(e(this, p), s);
+    return n.fetch().then(() => this.createResult(n, s));
+  }
+  fetch(t) {
+    return c(this, a, P).call(this, {
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), e(this, f)));
+  }
+  createResult(t, s) {
+    var ht;
+    const n = e(this, r), b = this.options, l = e(this, f), g = e(this, U), C = e(this, D), _ = t !== n ? t.state : e(this, j), { state: F } = t;
+    let o = { ...F }, st = !1, m;
+    if (s._optimisticResults) {
+      const d = this.hasListeners(), Q = !d && ft(t, s), T = d && pt(t, n, s, b);
+      (Q || T) && (o = {
+        ...o,
+        ...yt(F.data, t.options)
+      }), s._optimisticResults === "isRestoring" && (o.fetchStatus = "idle");
+    }
+    let { error: it, errorUpdatedAt: rt, status: I } = o;
+    if (s.select && o.data !== void 0)
+      if (l && o.data === (g == null ? void 0 : g.data) && s.select === e(this, A))
+        m = e(this, x);
+      else
+        try {
+          h(this, A, s.select), m = s.select(o.data), m = dt(l == null ? void 0 : l.data, m, s), h(this, x, m), h(this, y, null);
+        } catch (d) {
+          h(this, y, d);
+        }
+    else
+      m = o.data;
+    if (s.placeholderData !== void 0 && m === void 0 && I === "pending") {
+      let d;
+      if (l != null && l.isPlaceholderData && s.placeholderData === (C == null ? void 0 : C.placeholderData))
+        d = l.data;
+      else if (d = typeof s.placeholderData == "function" ? s.placeholderData(
+        (ht = e(this, L)) == null ? void 0 : ht.state.data,
+        e(this, L)
+      ) : s.placeholderData, s.select && d !== void 0)
+        try {
+          d = s.select(d), h(this, y, null);
+        } catch (Q) {
+          h(this, y, Q);
+        }
+      d !== void 0 && (I = "success", m = dt(
+        l == null ? void 0 : l.data,
+        d,
+        s
+      ), st = !0);
+    }
+    e(this, y) && (it = e(this, y), m = e(this, x), rt = Date.now(), I = "error");
+    const B = o.fetchStatus === "fetching", H = I === "pending", N = I === "error", nt = H && B, at = m !== void 0, R = {
+      status: I,
+      fetchStatus: o.fetchStatus,
+      isPending: H,
+      isSuccess: I === "success",
+      isError: N,
+      isInitialLoading: nt,
+      isLoading: nt,
+      data: m,
+      dataUpdatedAt: o.dataUpdatedAt,
+      error: it,
+      errorUpdatedAt: rt,
+      failureCount: o.fetchFailureCount,
+      failureReason: o.fetchFailureReason,
+      errorUpdateCount: o.errorUpdateCount,
+      isFetched: o.dataUpdateCount > 0 || o.errorUpdateCount > 0,
+      isFetchedAfterMount: o.dataUpdateCount > _.dataUpdateCount || o.errorUpdateCount > _.errorUpdateCount,
+      isFetching: B,
+      isRefetching: B && !H,
+      isLoadingError: N && !at,
+      isPaused: o.fetchStatus === "paused",
+      isPlaceholderData: st,
+      isRefetchError: N && at,
+      isStale: et(t, s),
+      refetch: this.refetch,
+      promise: e(this, O)
+    };
+    if (this.options.experimental_prefetchInRender) {
+      const d = (k) => {
+        R.status === "error" ? k.reject(R.error) : R.data !== void 0 && k.resolve(R.data);
+      }, Q = () => {
+        const k = h(this, O, R.promise = ct());
+        d(k);
+      }, T = e(this, O);
+      switch (T.status) {
+        case "pending":
+          t.queryHash === n.queryHash && d(T);
+          break;
+        case "fulfilled":
+          (R.status === "error" || R.data !== T.value) && Q();
+          break;
+        case "rejected":
+          (R.status !== "error" || R.error !== T.reason) && Q();
+          break;
+      }
+    }
+    return R;
+  }
+  updateResult(t) {
+    const s = e(this, f), n = this.createResult(e(this, r), this.options);
+    if (h(this, U, e(this, r).state), h(this, D, this.options), e(this, U).data !== void 0 && h(this, L, e(this, r)), K(n, s))
+      return;
+    h(this, f, n);
+    const b = {}, l = () => {
+      if (!s)
+        return !0;
+      const { notifyOnChangeProps: g } = this.options, C = typeof g == "function" ? g() : g;
+      if (C === "all" || !C && !e(this, M).size)
+        return !0;
+      const W = new Set(
+        C ?? e(this, M)
+      );
+      return this.options.throwOnError && W.add("error"), Object.keys(e(this, f)).some((_) => {
+        const F = _;
+        return e(this, f)[F] !== s[F] && W.has(F);
+      });
+    };
+    (t == null ? void 0 : t.listeners) !== !1 && l() && (b.listeners = !0), c(this, a, mt).call(this, { ...b, ...t });
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && c(this, a, Y).call(this);
+  }
+}, p = new WeakMap(), r = new WeakMap(), j = new WeakMap(), f = new WeakMap(), U = new WeakMap(), D = new WeakMap(), O = new WeakMap(), y = new WeakMap(), A = new WeakMap(), x = new WeakMap(), L = new WeakMap(), w = new WeakMap(), E = new WeakMap(), S = new WeakMap(), M = new WeakMap(), a = new WeakSet(), P = function(t) {
+  c(this, a, q).call(this);
+  let s = e(this, r).fetch(
+    this.options,
+    t
+  );
+  return t != null && t.throwOnError || (s = s.catch(Ot)), s;
+}, G = function() {
+  c(this, a, Z).call(this);
+  const t = z(
+    this.options.staleTime,
+    e(this, r)
+  );
+  if (lt || e(this, f).isStale || !ut(t))
+    return;
+  const n = St(e(this, f).dataUpdatedAt, t) + 1;
+  h(this, w, setTimeout(() => {
+    e(this, f).isStale || this.updateResult();
+  }, n));
+}, J = function() {
+  return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(e(this, r)) : this.options.refetchInterval) ?? !1;
+}, X = function(t) {
+  c(this, a, $).call(this), h(this, S, t), !(lt || v(this.options.enabled, e(this, r)) === !1 || !ut(e(this, S)) || e(this, S) === 0) && h(this, E, setInterval(() => {
+    (this.options.refetchIntervalInBackground || gt.isFocused()) && c(this, a, P).call(this);
+  }, e(this, S)));
+}, Y = function() {
+  c(this, a, G).call(this), c(this, a, X).call(this, c(this, a, J).call(this));
+}, Z = function() {
+  e(this, w) && (clearTimeout(e(this, w)), h(this, w, void 0));
+}, $ = function() {
+  e(this, E) && (clearInterval(e(this, E)), h(this, E, void 0));
+}, q = function() {
+  const t = e(this, p).getQueryCache().build(e(this, p), this.options);
+  if (t === e(this, r))
+    return;
+  const s = e(this, r);
+  h(this, r, t), h(this, j, t.state), this.hasListeners() && (s == null || s.removeObserver(this), t.addObserver(this));
+}, mt = function(t) {
+  Rt.batch(() => {
+    t.listeners && this.listeners.forEach((s) => {
+      s(e(this, f));
+    }), e(this, p).getQueryCache().notify({
+      query: e(this, r),
+      type: "observerResultsUpdated"
+    });
+  });
+}, bt);
+function Ct(i, t) {
+  return v(t.enabled, i) !== !1 && i.state.data === void 0 && !(i.state.status === "error" && t.retryOnMount === !1);
+}
+function ft(i, t) {
+  return Ct(i, t) || i.state.data !== void 0 && tt(i, t, t.refetchOnMount);
+}
+function tt(i, t, s) {
+  if (v(t.enabled, i) !== !1) {
+    const n = typeof s == "function" ? s(i) : s;
+    return n === "always" || n !== !1 && et(i, t);
+  }
+  return !1;
+}
+function pt(i, t, s, n) {
+  return (i !== t || v(n.enabled, i) === !1) && (!s.suspense || i.state.status !== "error") && et(i, s);
+}
+function et(i, t) {
+  return v(t.enabled, i) !== !1 && i.isStaleByTime(z(t.staleTime, i));
+}
+function It(i, t) {
+  return !K(i.getCurrentResult(), t);
+}
+export {
+  Lt as QueryObserver
+};