@rozenite/tanstack-query-plugin 1.5.1 → 1.7.0-rc.0

package/dist/useTanStackQueryDevTools.js

@@ -1,312 +0,0 @@
-import { useRozeniteDevToolsClient as b } from "@rozenite/plugin-bridge";
-import { useEffect as y, useRef as S, useMemo as q } from "react";
-import { onlineManager as h } from "@tanstack/react-query";
-import m from "fast-deep-equal";
-const H = (t) => {
-  y(() => {
-    if (!t)
-      return;
-    const a = h.subscribe((n) => {
-      t.send("online-status-changed", { online: n });
-    }), d = t.onMessage(
-      "online-status-changed",
-      ({ online: n }) => {
-        h.setOnline(n);
-      }
-    );
-    return () => {
-      a(), d.remove();
-    };
-  }, [t]);
-}, M = (t, a) => {
-  y(() => {
-    if (!a)
-      return;
-    const d = a.onMessage(
-      "devtools-action",
-      ({ type: n, queryHash: o }) => {
-        const s = t.getQueryCache().get(o);
-        if (!s) {
-          console.warn(`No active query found for hash: ${o}`);
-          return;
-        }
-        switch (n) {
-          case "TRIGGER_ERROR": {
-            const c = s.options, e = new Error("Unknown error from devtools");
-            s.setState({
-              status: "error",
-              error: e,
-              fetchMeta: {
-                ...s.state.fetchMeta,
-                // @ts-expect-error This does exist
-                __previousQueryOptions: c
-              }
-            });
-            break;
-          }
-          case "RESTORE_ERROR": {
-            t.resetQueries(s);
-            break;
-          }
-          case "TRIGGER_LOADING": {
-            if (!s) return;
-            const c = s.options;
-            s.fetch({
-              ...c,
-              queryFn: () => new Promise(() => {
-              }),
-              gcTime: -1
-            }), s.setState({
-              data: void 0,
-              status: "pending",
-              fetchMeta: {
-                ...s.state.fetchMeta,
-                // @ts-expect-error This does exist
-                __previousQueryOptions: c
-              }
-            });
-            break;
-          }
-          case "RESTORE_LOADING": {
-            const c = s.state, e = s.state.fetchMeta ? s.state.fetchMeta.__previousQueryOptions : null;
-            s.cancel({ silent: !0 }), s.setState({
-              ...c,
-              fetchStatus: "idle",
-              fetchMeta: null
-            }), e && s.fetch(e);
-            break;
-          }
-          case "RESET": {
-            t.resetQueries(s);
-            break;
-          }
-          case "REMOVE": {
-            t.removeQueries(s);
-            break;
-          }
-          case "REFETCH": {
-            s.fetch().catch(() => {
-            });
-            break;
-          }
-          case "INVALIDATE": {
-            t.invalidateQueries(s);
-            break;
-          }
-          default:
-            console.warn(`Unknown devtools action: ${n}`);
-        }
-      }
-    );
-    return () => {
-      d.remove();
-    };
-  }, [a]);
-}, f = (t) => t.observers.map((a) => ({
-  queryHash: t.queryHash,
-  options: a.options
-})), p = (t) => {
-  const a = f(t);
-  return {
-    state: t.state,
-    queryKey: t.queryKey,
-    queryHash: t.queryHash,
-    observers: a
-  };
-}, v = (t) => ({
-  mutationId: t.mutationId,
-  state: t.state,
-  options: t.options
-}), g = (t) => ({
-  queries: t.getQueryCache().getAll().map(p),
-  mutations: t.getMutationCache().getAll().map(v)
-}), R = (t, a) => {
-  const d = S(
-    /* @__PURE__ */ new Map()
-  ), n = q(() => (o) => {
-    if (!a || o.type === "observerResultsUpdated")
-      return;
-    if ("query" in o) {
-      const { query: e, type: u } = o;
-      if (u === "added" || u === "removed") {
-        u === "removed" && d.current.delete(e.queryHash);
-        const i = p(e);
-        a.send("sync-query-event", { type: u, data: i });
-        return;
-      }
-      if (u === "updated" && "action" in o) {
-        const i = o.action;
-        switch (i.type) {
-          case "fetch": {
-            const r = {
-              queryHash: e.queryHash,
-              state: {
-                status: e.state.status,
-                fetchStatus: e.state.fetchStatus,
-                fetchMeta: e.state.fetchMeta,
-                dataUpdatedAt: e.state.dataUpdatedAt,
-                errorUpdatedAt: e.state.errorUpdatedAt
-              }
-            };
-            a.send("sync-query-event", {
-              type: "updated",
-              action: "fetch",
-              data: r
-            });
-            break;
-          }
-          case "success": {
-            const r = {
-              queryHash: e.queryHash,
-              state: {
-                status: e.state.status,
-                data: e.state.data,
-                dataUpdatedAt: e.state.dataUpdatedAt,
-                error: e.state.error,
-                errorUpdatedAt: e.state.errorUpdatedAt,
-                fetchStatus: e.state.fetchStatus
-              }
-            };
-            a.send("sync-query-event", {
-              type: "updated",
-              action: "success",
-              data: r
-            });
-            break;
-          }
-          case "error": {
-            const r = {
-              queryHash: e.queryHash,
-              state: {
-                status: e.state.status,
-                error: e.state.error,
-                errorUpdatedAt: e.state.errorUpdatedAt,
-                fetchStatus: e.state.fetchStatus
-              }
-            };
-            a.send("sync-query-event", {
-              type: "updated",
-              action: "error",
-              data: r
-            });
-            break;
-          }
-          case "setState": {
-            const r = {
-              queryHash: e.queryHash,
-              state: i.state
-              // Only the changed state parts
-            };
-            a.send("sync-query-event", {
-              type: "updated",
-              action: "setState",
-              data: r
-            });
-            break;
-          }
-          case "invalidate": {
-            const r = {
-              queryHash: e.queryHash,
-              state: {
-                isInvalidated: e.state.isInvalidated
-              }
-            };
-            a.send("sync-query-event", {
-              type: "updated",
-              action: "invalidate",
-              data: r
-            });
-            break;
-          }
-          case "pause": {
-            const r = {
-              queryHash: e.queryHash,
-              state: {
-                fetchStatus: e.state.fetchStatus
-              }
-            };
-            a.send("sync-query-event", {
-              type: "updated",
-              action: "pause",
-              data: r
-            });
-            break;
-          }
-          case "continue": {
-            const r = {
-              queryHash: e.queryHash,
-              state: {
-                fetchStatus: e.state.fetchStatus
-              }
-            };
-            a.send("sync-query-event", {
-              type: "updated",
-              action: "continue",
-              data: r
-            });
-            break;
-          }
-          default: {
-            const r = p(e);
-            a.send("sync-query-event", { type: u, data: r });
-          }
-        }
-        return;
-      }
-      if (u === "observerAdded" || u === "observerRemoved" || u === "observerOptionsUpdated") {
-        const i = f(e), r = d.current.get(
-          e.queryHash
-        );
-        if (u === "observerOptionsUpdated" && r && m(r, i))
-          return;
-        d.current.set(
-          e.queryHash,
-          i
-        ), a.send("sync-query-event", {
-          type: u,
-          data: {
-            queryHash: e.queryHash,
-            observers: i
-          }
-        });
-        return;
-      }
-    }
-    const { mutation: s, type: c } = o;
-    if (s) {
-      const e = v(s);
-      a.send("sync-mutation-event", {
-        type: c,
-        data: e
-      });
-    }
-  }, [a]);
-  y(() => {
-    if (!a)
-      return;
-    const o = t.getMutationCache().subscribe(n), s = t.getQueryCache().subscribe(n);
-    return () => {
-      o(), s();
-    };
-  }, [a, t, n]);
-}, k = (t, a) => {
-  y(() => {
-    if (!a)
-      return;
-    const d = a.onMessage("request-initial-data", () => {
-      const n = g(t);
-      a.send("sync-data", { data: n });
-    });
-    return () => {
-      d.remove();
-    };
-  }, [a, t]);
-}, l = (t) => {
-  const a = b({
-    pluginId: "@rozenite/tanstack-query-plugin"
-  });
-  H(a), M(t, a), R(t, a), k(t, a);
-};
-export {
-  l as useTanStackQueryDevTools
-};