@scrippsproduct/networks-ui-library 1.1.0-alpha.7 → 1.1.0-alpha.9

package/dist/components/ScheduleLayout/ScheduleContext.js

@@ -1,33 +1,1926 @@
-import { jsx as S } from "react/jsx-runtime";
-import { createContext as g, useState as y, useRef as v, useCallback as x, useEffect as b, useMemo as j } from "react";
-const D = g(void 0);
-function L({
-  schedule: r,
-  weeks: a,
-  handleDateChanged: o = () => !0,
-  children: c
+var ye = (e) => {
+  throw TypeError(e);
+};
+var $t = (e, t, s) => t.has(e) || ye("Cannot " + s);
+var r = (e, t, s) => ($t(e, t, "read from private field"), s ? s.call(e) : t.get(e)), c = (e, t, s) => t.has(e) ? ye("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, s), o = (e, t, s, i) => ($t(e, t, "write to private field"), i ? i.call(e, s) : t.set(e, s), s), v = (e, t, s) => ($t(e, t, "access private method"), s);
+var Ht = (e, t, s, i) => ({
+  set _(n) {
+    o(e, t, n, s);
+  },
+  get _() {
+    return r(e, t, i);
+  }
+});
+import { jsx as Bt } from "react/jsx-runtime";
+import * as K from "react";
+import { createContext as ze, useState as pe, useRef as $e, useCallback as We, useEffect as Je, useMemo as Ze } from "react";
+import { f as Wt } from "../../format-YhWt2D8M.mjs";
+import { l as me } from "../../logger-C0N7U0YY.mjs";
+var Kt = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(e) {
+    return this.listeners.add(e), this.onSubscribe(), () => {
+      this.listeners.delete(e), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, Xe = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (e, t) => setTimeout(e, t),
+  clearTimeout: (e) => clearTimeout(e),
+  setInterval: (e, t) => setInterval(e, t),
+  clearInterval: (e) => clearInterval(e)
+}, G, ht, Me, Ye = (Me = class {
+  constructor() {
+    // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+    // type at app boot; and if we leave that type, then any new timer provider
+    // would need to support ReturnType<typeof setTimeout>, which is infeasible.
+    //
+    // We settle for type safety for the TimeoutProvider type, and accept that
+    // this class is unsafe internally to allow for extension.
+    c(this, G, Xe);
+    c(this, ht, !1);
+  }
+  setTimeoutProvider(e) {
+    process.env.NODE_ENV !== "production" && r(this, ht) && e !== r(this, G) && console.error(
+      "[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.",
+      { previous: r(this, G), provider: e }
+    ), o(this, G, e), process.env.NODE_ENV !== "production" && o(this, ht, !1);
+  }
+  setTimeout(e, t) {
+    return process.env.NODE_ENV !== "production" && o(this, ht, !0), r(this, G).setTimeout(e, t);
+  }
+  clearTimeout(e) {
+    r(this, G).clearTimeout(e);
+  }
+  setInterval(e, t) {
+    return process.env.NODE_ENV !== "production" && o(this, ht, !0), r(this, G).setInterval(e, t);
+  }
+  clearInterval(e) {
+    r(this, G).clearInterval(e);
+  }
+}, G = new WeakMap(), ht = new WeakMap(), Me), ut = new Ye();
+function ts(e) {
+  setTimeout(e, 0);
+}
+var bt = typeof window > "u" || "Deno" in globalThis;
+function j() {
+}
+function es(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Jt(e) {
+  return typeof e == "number" && e >= 0 && e !== 1 / 0;
+}
+function Ne(e, t) {
+  return Math.max(e + (t || 0) - Date.now(), 0);
+}
+function ot(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function k(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function ve(e, t) {
+  const {
+    type: s = "all",
+    exact: i,
+    fetchStatus: n,
+    predicate: a,
+    queryKey: h,
+    stale: u
+  } = e;
+  if (h) {
+    if (i) {
+      if (t.queryHash !== le(h, t.options))
+        return !1;
+    } else if (!xt(t.queryKey, h))
+      return !1;
+  }
+  if (s !== "all") {
+    const d = t.isActive();
+    if (s === "active" && !d || s === "inactive" && d)
+      return !1;
+  }
+  return !(typeof u == "boolean" && t.isStale() !== u || n && n !== t.state.fetchStatus || a && !a(t));
+}
+function ge(e, t) {
+  const { exact: s, status: i, predicate: n, mutationKey: a } = e;
+  if (a) {
+    if (!t.options.mutationKey)
+      return !1;
+    if (s) {
+      if (At(t.options.mutationKey) !== At(a))
+        return !1;
+    } else if (!xt(t.options.mutationKey, a))
+      return !1;
+  }
+  return !(i && t.state.status !== i || n && !n(t));
+}
+function le(e, t) {
+  return ((t == null ? void 0 : t.queryKeyHashFn) || At)(e);
+}
+function At(e) {
+  return JSON.stringify(
+    e,
+    (t, s) => Yt(s) ? Object.keys(s).sort().reduce((i, n) => (i[n] = s[n], i), {}) : s
+  );
+}
+function xt(e, t) {
+  return e === t ? !0 : typeof e != typeof t ? !1 : e && t && typeof e == "object" && typeof t == "object" ? Object.keys(t).every((s) => xt(e[s], t[s])) : !1;
+}
+var ss = Object.prototype.hasOwnProperty;
+function Zt(e, t) {
+  if (e === t)
+    return e;
+  const s = be(e) && be(t);
+  if (!s && !(Yt(e) && Yt(t))) return t;
+  const n = (s ? e : Object.keys(e)).length, a = s ? t : Object.keys(t), h = a.length, u = s ? new Array(h) : {};
+  let d = 0;
+  for (let b = 0; b < h; b++) {
+    const S = s ? b : a[b], f = e[S], O = t[S];
+    if (f === O) {
+      u[S] = f, (s ? b < n : ss.call(e, S)) && d++;
+      continue;
+    }
+    if (f === null || O === null || typeof f != "object" || typeof O != "object") {
+      u[S] = O;
+      continue;
+    }
+    const y = Zt(f, O);
+    u[S] = y, y === f && d++;
+  }
+  return n === h && d === n ? e : u;
+}
+function Xt(e, t) {
+  if (!t || Object.keys(e).length !== Object.keys(t).length)
+    return !1;
+  for (const s in e)
+    if (e[s] !== t[s])
+      return !1;
+  return !0;
+}
+function be(e) {
+  return Array.isArray(e) && e.length === Object.keys(e).length;
+}
+function Yt(e) {
+  if (!we(e))
+    return !1;
+  const t = e.constructor;
+  if (t === void 0)
+    return !0;
+  const s = t.prototype;
+  return !(!we(s) || !s.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+}
+function we(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function rs(e) {
+  return new Promise((t) => {
+    ut.setTimeout(t, e);
+  });
+}
+function te(e, t, s) {
+  if (typeof s.structuralSharing == "function")
+    return s.structuralSharing(e, t);
+  if (s.structuralSharing !== !1) {
+    if (process.env.NODE_ENV !== "production")
+      try {
+        return Zt(e, t);
+      } catch (i) {
+        throw console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${s.queryHash}]: ${i}`
+        ), i;
+      }
+    return Zt(e, t);
+  }
+  return t;
+}
+function is(e, t, s = 0) {
+  const i = [...e, t];
+  return s && i.length > s ? i.slice(1) : i;
+}
+function ns(e, t, s = 0) {
+  const i = [t, ...e];
+  return s && i.length > s ? i.slice(0, -1) : i;
+}
+var Vt = Symbol();
+function _e(e, t) {
+  return process.env.NODE_ENV !== "production" && e.queryFn === Vt && console.error(
+    `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${e.queryHash}'`
+  ), !e.queryFn && (t != null && t.initialPromise) ? () => t.initialPromise : !e.queryFn || e.queryFn === Vt ? () => Promise.reject(new Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
+}
+function as(e, t) {
+  return typeof e == "function" ? e(...t) : !!e;
+}
+var ct, tt, Ct, Qe, os = (Qe = class extends Kt {
+  constructor() {
+    super();
+    c(this, ct);
+    c(this, tt);
+    c(this, Ct);
+    o(this, Ct, (t) => {
+      if (!bt && window.addEventListener) {
+        const s = () => t();
+        return window.addEventListener("visibilitychange", s, !1), () => {
+          window.removeEventListener("visibilitychange", s);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    r(this, tt) || this.setEventListener(r(this, Ct));
+  }
+  onUnsubscribe() {
+    var t;
+    this.hasListeners() || ((t = r(this, tt)) == null || t.call(this), o(this, tt, void 0));
+  }
+  setEventListener(t) {
+    var s;
+    o(this, Ct, t), (s = r(this, tt)) == null || s.call(this), o(this, tt, t((i) => {
+      typeof i == "boolean" ? this.setFocused(i) : this.onFocus();
+    }));
+  }
+  setFocused(t) {
+    r(this, ct) !== t && (o(this, ct, t), this.onFocus());
+  }
+  onFocus() {
+    const t = this.isFocused();
+    this.listeners.forEach((s) => {
+      s(t);
+    });
+  }
+  isFocused() {
+    var t;
+    return typeof r(this, ct) == "boolean" ? r(this, ct) : ((t = globalThis.document) == null ? void 0 : t.visibilityState) !== "hidden";
+  }
+}, ct = new WeakMap(), tt = new WeakMap(), Ct = new WeakMap(), Qe), de = new os();
+function ee() {
+  let e, t;
+  const s = new Promise((n, a) => {
+    e = n, t = a;
+  });
+  s.status = "pending", s.catch(() => {
+  });
+  function i(n) {
+    Object.assign(s, n), delete s.resolve, delete s.reject;
+  }
+  return s.resolve = (n) => {
+    i({
+      status: "fulfilled",
+      value: n
+    }), e(n);
+  }, s.reject = (n) => {
+    i({
+      status: "rejected",
+      reason: n
+    }), t(n);
+  }, s;
+}
+var us = ts;
+function hs() {
+  let e = [], t = 0, s = (u) => {
+    u();
+  }, i = (u) => {
+    u();
+  }, n = us;
+  const a = (u) => {
+    t ? e.push(u) : n(() => {
+      s(u);
+    });
+  }, h = () => {
+    const u = e;
+    e = [], u.length && n(() => {
+      i(() => {
+        u.forEach((d) => {
+          s(d);
+        });
+      });
+    });
+  };
+  return {
+    batch: (u) => {
+      let d;
+      t++;
+      try {
+        d = u();
+      } finally {
+        t--, t || h();
+      }
+      return d;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (u) => (...d) => {
+      a(() => {
+        u(...d);
+      });
+    },
+    schedule: a,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: (u) => {
+      s = u;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: (u) => {
+      i = u;
+    },
+    setScheduler: (u) => {
+      n = u;
+    }
+  };
+}
+var T = hs(), St, et, Ot, De, cs = (De = class extends Kt {
+  constructor() {
+    super();
+    c(this, St, !0);
+    c(this, et);
+    c(this, Ot);
+    o(this, Ot, (t) => {
+      if (!bt && window.addEventListener) {
+        const s = () => t(!0), i = () => t(!1);
+        return window.addEventListener("online", s, !1), window.addEventListener("offline", i, !1), () => {
+          window.removeEventListener("online", s), window.removeEventListener("offline", i);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    r(this, et) || this.setEventListener(r(this, Ot));
+  }
+  onUnsubscribe() {
+    var t;
+    this.hasListeners() || ((t = r(this, et)) == null || t.call(this), o(this, et, void 0));
+  }
+  setEventListener(t) {
+    var s;
+    o(this, Ot, t), (s = r(this, et)) == null || s.call(this), o(this, et, t(this.setOnline.bind(this)));
+  }
+  setOnline(t) {
+    r(this, St) !== t && (o(this, St, t), this.listeners.forEach((i) => {
+      i(t);
+    }));
+  }
+  isOnline() {
+    return r(this, St);
+  }
+}, St = new WeakMap(), et = new WeakMap(), Ot = new WeakMap(), De), zt = new cs();
+function ls(e) {
+  return Math.min(1e3 * 2 ** e, 3e4);
+}
+function ke(e) {
+  return (e ?? "online") === "online" ? zt.isOnline() : !0;
+}
+var se = class extends Error {
+  constructor(e) {
+    super("CancelledError"), this.revert = e == null ? void 0 : e.revert, this.silent = e == null ? void 0 : e.silent;
+  }
+};
+function Ke(e) {
+  let t = !1, s = 0, i;
+  const n = ee(), a = () => n.status !== "pending", h = (p) => {
+    var m;
+    if (!a()) {
+      const P = new se(p);
+      O(P), (m = e.onCancel) == null || m.call(e, P);
+    }
+  }, u = () => {
+    t = !0;
+  }, d = () => {
+    t = !1;
+  }, b = () => de.isFocused() && (e.networkMode === "always" || zt.isOnline()) && e.canRun(), S = () => ke(e.networkMode) && e.canRun(), f = (p) => {
+    a() || (i == null || i(), n.resolve(p));
+  }, O = (p) => {
+    a() || (i == null || i(), n.reject(p));
+  }, y = () => new Promise((p) => {
+    var m;
+    i = (P) => {
+      (a() || b()) && p(P);
+    }, (m = e.onPause) == null || m.call(e);
+  }).then(() => {
+    var p;
+    i = void 0, a() || (p = e.onContinue) == null || p.call(e);
+  }), R = () => {
+    if (a())
+      return;
+    let p;
+    const m = s === 0 ? e.initialPromise : void 0;
+    try {
+      p = m ?? e.fn();
+    } catch (P) {
+      p = Promise.reject(P);
+    }
+    Promise.resolve(p).then(f).catch((P) => {
+      var x;
+      if (a())
+        return;
+      const M = e.retry ?? (bt ? 0 : 3), E = e.retryDelay ?? ls, l = typeof E == "function" ? E(s, P) : E, Q = M === !0 || typeof M == "number" && s < M || typeof M == "function" && M(s, P);
+      if (t || !Q) {
+        O(P);
+        return;
+      }
+      s++, (x = e.onFail) == null || x.call(e, s, P), rs(l).then(() => b() ? void 0 : y()).then(() => {
+        t ? O(P) : R();
+      });
+    });
+  };
+  return {
+    promise: n,
+    status: () => n.status,
+    cancel: h,
+    continue: () => (i == null || i(), n),
+    cancelRetry: u,
+    continueRetry: d,
+    canStart: S,
+    start: () => (S() ? R() : y().then(R), n)
+  };
+}
+var lt, Te, Le = (Te = class {
+  constructor() {
+    c(this, lt);
+  }
+  destroy() {
+    this.clearGcTimeout();
+  }
+  scheduleGc() {
+    this.clearGcTimeout(), Jt(this.gcTime) && o(this, lt, ut.setTimeout(() => {
+      this.optionalRemove();
+    }, this.gcTime));
+  }
+  updateGcTime(e) {
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      e ?? (bt ? 1 / 0 : 300 * 1e3)
+    );
+  }
+  clearGcTimeout() {
+    r(this, lt) && (ut.clearTimeout(r(this, lt)), o(this, lt, void 0));
+  }
+}, lt = new WeakMap(), Te), dt, Pt, _, ft, D, Ut, yt, L, $, Ie, ds = (Ie = class extends Le {
+  constructor(t) {
+    super();
+    c(this, L);
+    c(this, dt);
+    c(this, Pt);
+    c(this, _);
+    c(this, ft);
+    c(this, D);
+    c(this, Ut);
+    c(this, yt);
+    o(this, yt, !1), o(this, Ut, t.defaultOptions), this.setOptions(t.options), this.observers = [], o(this, ft, t.client), o(this, _, r(this, ft).getQueryCache()), this.queryKey = t.queryKey, this.queryHash = t.queryHash, o(this, dt, Se(this.options)), this.state = t.state ?? r(this, dt), this.scheduleGc();
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  get promise() {
+    var t;
+    return (t = r(this, D)) == null ? void 0 : t.promise;
+  }
+  setOptions(t) {
+    if (this.options = { ...r(this, Ut), ...t }, this.updateGcTime(this.options.gcTime), this.state && this.state.data === void 0) {
+      const s = Se(this.options);
+      s.data !== void 0 && (this.setState(
+        Ce(s.data, s.dataUpdatedAt)
+      ), o(this, dt, s));
+    }
+  }
+  optionalRemove() {
+    !this.observers.length && this.state.fetchStatus === "idle" && r(this, _).remove(this);
+  }
+  setData(t, s) {
+    const i = te(this.state.data, t, this.options);
+    return v(this, L, $).call(this, {
+      data: i,
+      type: "success",
+      dataUpdatedAt: s == null ? void 0 : s.updatedAt,
+      manual: s == null ? void 0 : s.manual
+    }), i;
+  }
+  setState(t, s) {
+    v(this, L, $).call(this, { type: "setState", state: t, setStateOptions: s });
+  }
+  cancel(t) {
+    var i, n;
+    const s = (i = r(this, D)) == null ? void 0 : i.promise;
+    return (n = r(this, D)) == null || n.cancel(t), s ? s.then(j).catch(j) : Promise.resolve();
+  }
+  destroy() {
+    super.destroy(), this.cancel({ silent: !0 });
+  }
+  reset() {
+    this.destroy(), this.setState(r(this, dt));
+  }
+  isActive() {
+    return this.observers.some(
+      (t) => k(t.options.enabled, this) !== !1
+    );
+  }
+  isDisabled() {
+    return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === Vt || this.state.dataUpdateCount + this.state.errorUpdateCount === 0;
+  }
+  isStatic() {
+    return this.getObserversCount() > 0 ? this.observers.some(
+      (t) => ot(t.options.staleTime, this) === "static"
+    ) : !1;
+  }
+  isStale() {
+    return this.getObserversCount() > 0 ? this.observers.some(
+      (t) => t.getCurrentResult().isStale
+    ) : this.state.data === void 0 || this.state.isInvalidated;
+  }
+  isStaleByTime(t = 0) {
+    return this.state.data === void 0 ? !0 : t === "static" ? !1 : this.state.isInvalidated ? !0 : !Ne(this.state.dataUpdatedAt, t);
+  }
+  onFocus() {
+    var s;
+    const t = this.observers.find((i) => i.shouldFetchOnWindowFocus());
+    t == null || t.refetch({ cancelRefetch: !1 }), (s = r(this, D)) == null || s.continue();
+  }
+  onOnline() {
+    var s;
+    const t = this.observers.find((i) => i.shouldFetchOnReconnect());
+    t == null || t.refetch({ cancelRefetch: !1 }), (s = r(this, D)) == null || s.continue();
+  }
+  addObserver(t) {
+    this.observers.includes(t) || (this.observers.push(t), this.clearGcTimeout(), r(this, _).notify({ type: "observerAdded", query: this, observer: t }));
+  }
+  removeObserver(t) {
+    this.observers.includes(t) && (this.observers = this.observers.filter((s) => s !== t), this.observers.length || (r(this, D) && (r(this, yt) ? r(this, D).cancel({ revert: !0 }) : r(this, D).cancelRetry()), this.scheduleGc()), r(this, _).notify({ type: "observerRemoved", query: this, observer: t }));
+  }
+  getObserversCount() {
+    return this.observers.length;
+  }
+  invalidate() {
+    this.state.isInvalidated || v(this, L, $).call(this, { type: "invalidate" });
+  }
+  async fetch(t, s) {
+    var d, b, S, f, O, y, R, p, m, P, M, E;
+    if (this.state.fetchStatus !== "idle" && // If the promise in the retyer is already rejected, we have to definitely
+    // re-start the fetch; there is a chance that the query is still in a
+    // pending state when that happens
+    ((d = r(this, D)) == null ? void 0 : d.status()) !== "rejected") {
+      if (this.state.data !== void 0 && (s != null && s.cancelRefetch))
+        this.cancel({ silent: !0 });
+      else if (r(this, D))
+        return r(this, D).continueRetry(), r(this, D).promise;
+    }
+    if (t && this.setOptions(t), !this.options.queryFn) {
+      const l = this.observers.find((Q) => Q.options.queryFn);
+      l && this.setOptions(l.options);
+    }
+    process.env.NODE_ENV !== "production" && (Array.isArray(this.options.queryKey) || console.error(
+      "As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']"
+    ));
+    const i = new AbortController(), n = (l) => {
+      Object.defineProperty(l, "signal", {
+        enumerable: !0,
+        get: () => (o(this, yt, !0), i.signal)
+      });
+    }, a = () => {
+      const l = _e(this.options, s), x = (() => {
+        const Z = {
+          client: r(this, ft),
+          queryKey: this.queryKey,
+          meta: this.meta
+        };
+        return n(Z), Z;
+      })();
+      return o(this, yt, !1), this.options.persister ? this.options.persister(
+        l,
+        x,
+        this
+      ) : l(x);
+    }, u = (() => {
+      const l = {
+        fetchOptions: s,
+        options: this.options,
+        queryKey: this.queryKey,
+        client: r(this, ft),
+        state: this.state,
+        fetchFn: a
+      };
+      return n(l), l;
+    })();
+    (b = this.options.behavior) == null || b.onFetch(u, this), o(this, Pt, this.state), (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((S = u.fetchOptions) == null ? void 0 : S.meta)) && v(this, L, $).call(this, { type: "fetch", meta: (f = u.fetchOptions) == null ? void 0 : f.meta }), o(this, D, Ke({
+      initialPromise: s == null ? void 0 : s.initialPromise,
+      fn: u.fetchFn,
+      onCancel: (l) => {
+        l instanceof se && l.revert && this.setState({
+          ...r(this, Pt),
+          fetchStatus: "idle"
+        }), i.abort();
+      },
+      onFail: (l, Q) => {
+        v(this, L, $).call(this, { type: "failed", failureCount: l, error: Q });
+      },
+      onPause: () => {
+        v(this, L, $).call(this, { type: "pause" });
+      },
+      onContinue: () => {
+        v(this, L, $).call(this, { type: "continue" });
+      },
+      retry: u.options.retry,
+      retryDelay: u.options.retryDelay,
+      networkMode: u.options.networkMode,
+      canRun: () => !0
+    }));
+    try {
+      const l = await r(this, D).start();
+      if (l === void 0)
+        throw process.env.NODE_ENV !== "production" && console.error(
+          `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`
+        ), new Error(`${this.queryHash} data is undefined`);
+      return this.setData(l), (y = (O = r(this, _).config).onSuccess) == null || y.call(O, l, this), (p = (R = r(this, _).config).onSettled) == null || p.call(
+        R,
+        l,
+        this.state.error,
+        this
+      ), l;
+    } catch (l) {
+      if (l instanceof se) {
+        if (l.silent)
+          return r(this, D).promise;
+        if (l.revert) {
+          if (this.state.data === void 0)
+            throw l;
+          return this.state.data;
+        }
+      }
+      throw v(this, L, $).call(this, {
+        type: "error",
+        error: l
+      }), (P = (m = r(this, _).config).onError) == null || P.call(
+        m,
+        l,
+        this
+      ), (E = (M = r(this, _).config).onSettled) == null || E.call(
+        M,
+        this.state.data,
+        l,
+        this
+      ), l;
+    } finally {
+      this.scheduleGc();
+    }
+  }
+}, dt = new WeakMap(), Pt = new WeakMap(), _ = new WeakMap(), ft = new WeakMap(), D = new WeakMap(), Ut = new WeakMap(), yt = new WeakMap(), L = new WeakSet(), $ = function(t) {
+  const s = (i) => {
+    switch (t.type) {
+      case "failed":
+        return {
+          ...i,
+          fetchFailureCount: t.failureCount,
+          fetchFailureReason: t.error
+        };
+      case "pause":
+        return {
+          ...i,
+          fetchStatus: "paused"
+        };
+      case "continue":
+        return {
+          ...i,
+          fetchStatus: "fetching"
+        };
+      case "fetch":
+        return {
+          ...i,
+          ...He(i.data, this.options),
+          fetchMeta: t.meta ?? null
+        };
+      case "success":
+        const n = {
+          ...i,
+          ...Ce(t.data, t.dataUpdatedAt),
+          dataUpdateCount: i.dataUpdateCount + 1,
+          ...!t.manual && {
+            fetchStatus: "idle",
+            fetchFailureCount: 0,
+            fetchFailureReason: null
+          }
+        };
+        return o(this, Pt, t.manual ? n : void 0), n;
+      case "error":
+        const a = t.error;
+        return {
+          ...i,
+          error: a,
+          errorUpdateCount: i.errorUpdateCount + 1,
+          errorUpdatedAt: Date.now(),
+          fetchFailureCount: i.fetchFailureCount + 1,
+          fetchFailureReason: a,
+          fetchStatus: "idle",
+          status: "error"
+        };
+      case "invalidate":
+        return {
+          ...i,
+          isInvalidated: !0
+        };
+      case "setState":
+        return {
+          ...i,
+          ...t.state
+        };
+    }
+  };
+  this.state = s(this.state), T.batch(() => {
+    this.observers.forEach((i) => {
+      i.onQueryUpdate();
+    }), r(this, _).notify({ query: this, type: "updated", action: t });
+  });
+}, Ie);
+function He(e, t) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: ke(t.networkMode) ? "fetching" : "paused",
+    ...e === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+function Ce(e, t) {
+  return {
+    data: e,
+    dataUpdatedAt: t ?? Date.now(),
+    error: null,
+    isInvalidated: !1,
+    status: "success"
+  };
+}
+function Se(e) {
+  const t = typeof e.initialData == "function" ? e.initialData() : e.initialData, s = t !== void 0, i = s ? typeof e.initialDataUpdatedAt == "function" ? e.initialDataUpdatedAt() : e.initialDataUpdatedAt : 0;
+  return {
+    data: t,
+    dataUpdateCount: 0,
+    dataUpdatedAt: s ? i ?? Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: !1,
+    status: s ? "success" : "pending",
+    fetchStatus: "idle"
+  };
+}
+var U, g, jt, q, pt, Et, W, st, Nt, Ft, Rt, mt, vt, rt, Mt, C, qt, re, ie, ne, ae, oe, ue, he, Ge, qe, fs = (qe = class extends Kt {
+  constructor(t, s) {
+    super();
+    c(this, C);
+    c(this, U);
+    c(this, g);
+    c(this, jt);
+    c(this, q);
+    c(this, pt);
+    c(this, Et);
+    c(this, W);
+    c(this, st);
+    c(this, Nt);
+    c(this, Ft);
+    // 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.
+    c(this, Rt);
+    c(this, mt);
+    c(this, vt);
+    c(this, rt);
+    c(this, Mt, /* @__PURE__ */ new Set());
+    this.options = s, o(this, U, t), o(this, st, null), o(this, W, ee()), this.bindMethods(), this.setOptions(s);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (r(this, g).addObserver(this), Oe(r(this, g), this.options) ? v(this, C, qt).call(this) : this.updateResult(), v(this, C, ae).call(this));
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return ce(
+      r(this, g),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return ce(
+      r(this, g),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), v(this, C, oe).call(this), v(this, C, ue).call(this), r(this, g).removeObserver(this);
+  }
+  setOptions(t) {
+    const s = this.options, i = r(this, g);
+    if (this.options = r(this, U).defaultQueryOptions(t), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof k(this.options.enabled, r(this, g)) != "boolean")
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    v(this, C, he).call(this), r(this, g).setOptions(this.options), s._defaulted && !Xt(this.options, s) && r(this, U).getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: r(this, g),
+      observer: this
+    });
+    const n = this.hasListeners();
+    n && Pe(
+      r(this, g),
+      i,
+      this.options,
+      s
+    ) && v(this, C, qt).call(this), this.updateResult(), n && (r(this, g) !== i || k(this.options.enabled, r(this, g)) !== k(s.enabled, r(this, g)) || ot(this.options.staleTime, r(this, g)) !== ot(s.staleTime, r(this, g))) && v(this, C, re).call(this);
+    const a = v(this, C, ie).call(this);
+    n && (r(this, g) !== i || k(this.options.enabled, r(this, g)) !== k(s.enabled, r(this, g)) || a !== r(this, rt)) && v(this, C, ne).call(this, a);
+  }
+  getOptimisticResult(t) {
+    const s = r(this, U).getQueryCache().build(r(this, U), t), i = this.createResult(s, t);
+    return ps(this, i) && (o(this, q, i), o(this, Et, this.options), o(this, pt, r(this, g).state)), i;
+  }
+  getCurrentResult() {
+    return r(this, q);
+  }
+  trackResult(t, s) {
+    return new Proxy(t, {
+      get: (i, n) => (this.trackProp(n), s == null || s(n), n === "promise" && (this.trackProp("data"), !this.options.experimental_prefetchInRender && r(this, W).status === "pending" && r(this, W).reject(
+        new Error(
+          "experimental_prefetchInRender feature flag is not enabled"
+        )
+      )), Reflect.get(i, n))
+    });
+  }
+  trackProp(t) {
+    r(this, Mt).add(t);
+  }
+  getCurrentQuery() {
+    return r(this, g);
+  }
+  refetch({ ...t } = {}) {
+    return this.fetch({
+      ...t
+    });
+  }
+  fetchOptimistic(t) {
+    const s = r(this, U).defaultQueryOptions(t), i = r(this, U).getQueryCache().build(r(this, U), s);
+    return i.fetch().then(() => this.createResult(i, s));
+  }
+  fetch(t) {
+    return v(this, C, qt).call(this, {
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), r(this, q)));
+  }
+  createResult(t, s) {
+    var X;
+    const i = r(this, g), n = this.options, a = r(this, q), h = r(this, pt), u = r(this, Et), b = t !== i ? t.state : r(this, jt), { state: S } = t;
+    let f = { ...S }, O = !1, y;
+    if (s._optimisticResults) {
+      const w = this.hasListeners(), N = !w && Oe(t, s), wt = w && Pe(t, i, s, n);
+      (N || wt) && (f = {
+        ...f,
+        ...He(S.data, t.options)
+      }), s._optimisticResults === "isRestoring" && (f.fetchStatus = "idle");
+    }
+    let { error: R, errorUpdatedAt: p, status: m } = f;
+    y = f.data;
+    let P = !1;
+    if (s.placeholderData !== void 0 && y === void 0 && m === "pending") {
+      let w;
+      a != null && a.isPlaceholderData && s.placeholderData === (u == null ? void 0 : u.placeholderData) ? (w = a.data, P = !0) : w = typeof s.placeholderData == "function" ? s.placeholderData(
+        (X = r(this, Rt)) == null ? void 0 : X.state.data,
+        r(this, Rt)
+      ) : s.placeholderData, w !== void 0 && (m = "success", y = te(
+        a == null ? void 0 : a.data,
+        w,
+        s
+      ), O = !0);
+    }
+    if (s.select && y !== void 0 && !P)
+      if (a && y === (h == null ? void 0 : h.data) && s.select === r(this, Nt))
+        y = r(this, Ft);
+      else
+        try {
+          o(this, Nt, s.select), y = s.select(y), y = te(a == null ? void 0 : a.data, y, s), o(this, Ft, y), o(this, st, null);
+        } catch (w) {
+          o(this, st, w);
+        }
+    r(this, st) && (R = r(this, st), y = r(this, Ft), p = Date.now(), m = "error");
+    const M = f.fetchStatus === "fetching", E = m === "pending", l = m === "error", Q = E && M, x = y !== void 0, I = {
+      status: m,
+      fetchStatus: f.fetchStatus,
+      isPending: E,
+      isSuccess: m === "success",
+      isError: l,
+      isInitialLoading: Q,
+      isLoading: Q,
+      data: y,
+      dataUpdatedAt: f.dataUpdatedAt,
+      error: R,
+      errorUpdatedAt: p,
+      failureCount: f.fetchFailureCount,
+      failureReason: f.fetchFailureReason,
+      errorUpdateCount: f.errorUpdateCount,
+      isFetched: f.dataUpdateCount > 0 || f.errorUpdateCount > 0,
+      isFetchedAfterMount: f.dataUpdateCount > b.dataUpdateCount || f.errorUpdateCount > b.errorUpdateCount,
+      isFetching: M,
+      isRefetching: M && !E,
+      isLoadingError: l && !x,
+      isPaused: f.fetchStatus === "paused",
+      isPlaceholderData: O,
+      isRefetchError: l && x,
+      isStale: fe(t, s),
+      refetch: this.refetch,
+      promise: r(this, W),
+      isEnabled: k(s.enabled, t) !== !1
+    };
+    if (this.options.experimental_prefetchInRender) {
+      const w = (Lt) => {
+        I.status === "error" ? Lt.reject(I.error) : I.data !== void 0 && Lt.resolve(I.data);
+      }, N = () => {
+        const Lt = o(this, W, I.promise = ee());
+        w(Lt);
+      }, wt = r(this, W);
+      switch (wt.status) {
+        case "pending":
+          t.queryHash === i.queryHash && w(wt);
+          break;
+        case "fulfilled":
+          (I.status === "error" || I.data !== wt.value) && N();
+          break;
+        case "rejected":
+          (I.status !== "error" || I.error !== wt.reason) && N();
+          break;
+      }
+    }
+    return I;
+  }
+  updateResult() {
+    const t = r(this, q), s = this.createResult(r(this, g), this.options);
+    if (o(this, pt, r(this, g).state), o(this, Et, this.options), r(this, pt).data !== void 0 && o(this, Rt, r(this, g)), Xt(s, t))
+      return;
+    o(this, q, s);
+    const i = () => {
+      if (!t)
+        return !0;
+      const { notifyOnChangeProps: n } = this.options, a = typeof n == "function" ? n() : n;
+      if (a === "all" || !a && !r(this, Mt).size)
+        return !0;
+      const h = new Set(
+        a ?? r(this, Mt)
+      );
+      return this.options.throwOnError && h.add("error"), Object.keys(r(this, q)).some((u) => {
+        const d = u;
+        return r(this, q)[d] !== t[d] && h.has(d);
+      });
+    };
+    v(this, C, Ge).call(this, { listeners: i() });
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && v(this, C, ae).call(this);
+  }
+}, U = new WeakMap(), g = new WeakMap(), jt = new WeakMap(), q = new WeakMap(), pt = new WeakMap(), Et = new WeakMap(), W = new WeakMap(), st = new WeakMap(), Nt = new WeakMap(), Ft = new WeakMap(), Rt = new WeakMap(), mt = new WeakMap(), vt = new WeakMap(), rt = new WeakMap(), Mt = new WeakMap(), C = new WeakSet(), qt = function(t) {
+  v(this, C, he).call(this);
+  let s = r(this, g).fetch(
+    this.options,
+    t
+  );
+  return t != null && t.throwOnError || (s = s.catch(j)), s;
+}, re = function() {
+  v(this, C, oe).call(this);
+  const t = ot(
+    this.options.staleTime,
+    r(this, g)
+  );
+  if (bt || r(this, q).isStale || !Jt(t))
+    return;
+  const i = Ne(r(this, q).dataUpdatedAt, t) + 1;
+  o(this, mt, ut.setTimeout(() => {
+    r(this, q).isStale || this.updateResult();
+  }, i));
+}, ie = function() {
+  return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(r(this, g)) : this.options.refetchInterval) ?? !1;
+}, ne = function(t) {
+  v(this, C, ue).call(this), o(this, rt, t), !(bt || k(this.options.enabled, r(this, g)) === !1 || !Jt(r(this, rt)) || r(this, rt) === 0) && o(this, vt, ut.setInterval(() => {
+    (this.options.refetchIntervalInBackground || de.isFocused()) && v(this, C, qt).call(this);
+  }, r(this, rt)));
+}, ae = function() {
+  v(this, C, re).call(this), v(this, C, ne).call(this, v(this, C, ie).call(this));
+}, oe = function() {
+  r(this, mt) && (ut.clearTimeout(r(this, mt)), o(this, mt, void 0));
+}, ue = function() {
+  r(this, vt) && (ut.clearInterval(r(this, vt)), o(this, vt, void 0));
+}, he = function() {
+  const t = r(this, U).getQueryCache().build(r(this, U), this.options);
+  if (t === r(this, g))
+    return;
+  const s = r(this, g);
+  o(this, g, t), o(this, jt, t.state), this.hasListeners() && (s == null || s.removeObserver(this), t.addObserver(this));
+}, Ge = function(t) {
+  T.batch(() => {
+    t.listeners && this.listeners.forEach((s) => {
+      s(r(this, q));
+    }), r(this, U).getQueryCache().notify({
+      query: r(this, g),
+      type: "observerResultsUpdated"
+    });
+  });
+}, qe);
+function ys(e, t) {
+  return k(t.enabled, e) !== !1 && e.state.data === void 0 && !(e.state.status === "error" && t.retryOnMount === !1);
+}
+function Oe(e, t) {
+  return ys(e, t) || e.state.data !== void 0 && ce(e, t, t.refetchOnMount);
+}
+function ce(e, t, s) {
+  if (k(t.enabled, e) !== !1 && ot(t.staleTime, e) !== "static") {
+    const i = typeof s == "function" ? s(e) : s;
+    return i === "always" || i !== !1 && fe(e, t);
+  }
+  return !1;
+}
+function Pe(e, t, s, i) {
+  return (e !== t || k(i.enabled, e) === !1) && (!s.suspense || e.state.status !== "error") && fe(e, s);
+}
+function fe(e, t) {
+  return k(t.enabled, e) !== !1 && e.isStaleByTime(ot(t.staleTime, e));
+}
+function ps(e, t) {
+  return !Xt(e.getCurrentResult(), t);
+}
+function Ee(e) {
+  return {
+    onFetch: (t, s) => {
+      var S, f, O, y, R;
+      const i = t.options, n = (O = (f = (S = t.fetchOptions) == null ? void 0 : S.meta) == null ? void 0 : f.fetchMore) == null ? void 0 : O.direction, a = ((y = t.state.data) == null ? void 0 : y.pages) || [], h = ((R = t.state.data) == null ? void 0 : R.pageParams) || [];
+      let u = { pages: [], pageParams: [] }, d = 0;
+      const b = async () => {
+        let p = !1;
+        const m = (E) => {
+          Object.defineProperty(E, "signal", {
+            enumerable: !0,
+            get: () => (t.signal.aborted ? p = !0 : t.signal.addEventListener("abort", () => {
+              p = !0;
+            }), t.signal)
+          });
+        }, P = _e(t.options, t.fetchOptions), M = async (E, l, Q) => {
+          if (p)
+            return Promise.reject();
+          if (l == null && E.pages.length)
+            return Promise.resolve(E);
+          const Z = (() => {
+            const N = {
+              client: t.client,
+              queryKey: t.queryKey,
+              pageParam: l,
+              direction: Q ? "backward" : "forward",
+              meta: t.options.meta
+            };
+            return m(N), N;
+          })(), I = await P(Z), { maxPages: X } = t.options, w = Q ? ns : is;
+          return {
+            pages: w(E.pages, I, X),
+            pageParams: w(E.pageParams, l, X)
+          };
+        };
+        if (n && a.length) {
+          const E = n === "backward", l = E ? ms : Fe, Q = {
+            pages: a,
+            pageParams: h
+          }, x = l(i, Q);
+          u = await M(Q, x, E);
+        } else {
+          const E = e ?? a.length;
+          do {
+            const l = d === 0 ? h[0] ?? i.initialPageParam : Fe(i, u);
+            if (d > 0 && l == null)
+              break;
+            u = await M(u, l), d++;
+          } while (d < E);
+        }
+        return u;
+      };
+      t.options.persister ? t.fetchFn = () => {
+        var p, m;
+        return (m = (p = t.options).persister) == null ? void 0 : m.call(
+          p,
+          b,
+          {
+            client: t.client,
+            queryKey: t.queryKey,
+            meta: t.options.meta,
+            signal: t.signal
+          },
+          s
+        );
+      } : t.fetchFn = b;
+    }
+  };
+}
+function Fe(e, { pages: t, pageParams: s }) {
+  const i = t.length - 1;
+  return t.length > 0 ? e.getNextPageParam(
+    t[i],
+    t,
+    s[i],
+    s
+  ) : void 0;
+}
+function ms(e, { pages: t, pageParams: s }) {
+  var i;
+  return t.length > 0 ? (i = e.getPreviousPageParam) == null ? void 0 : i.call(e, t[0], t, s[0], s) : void 0;
+}
+var _t, B, A, gt, V, Y, Ae, vs = (Ae = class extends Le {
+  constructor(t) {
+    super();
+    c(this, V);
+    c(this, _t);
+    c(this, B);
+    c(this, A);
+    c(this, gt);
+    o(this, _t, t.client), this.mutationId = t.mutationId, o(this, A, t.mutationCache), o(this, B, []), this.state = t.state || gs(), this.setOptions(t.options), this.scheduleGc();
+  }
+  setOptions(t) {
+    this.options = t, this.updateGcTime(this.options.gcTime);
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  addObserver(t) {
+    r(this, B).includes(t) || (r(this, B).push(t), this.clearGcTimeout(), r(this, A).notify({
+      type: "observerAdded",
+      mutation: this,
+      observer: t
+    }));
+  }
+  removeObserver(t) {
+    o(this, B, r(this, B).filter((s) => s !== t)), this.scheduleGc(), r(this, A).notify({
+      type: "observerRemoved",
+      mutation: this,
+      observer: t
+    });
+  }
+  optionalRemove() {
+    r(this, B).length || (this.state.status === "pending" ? this.scheduleGc() : r(this, A).remove(this));
+  }
+  continue() {
+    var t;
+    return ((t = r(this, gt)) == null ? void 0 : t.continue()) ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+    this.execute(this.state.variables);
+  }
+  async execute(t) {
+    var h, u, d, b, S, f, O, y, R, p, m, P, M, E, l, Q, x, Z, I, X;
+    const s = () => {
+      v(this, V, Y).call(this, { type: "continue" });
+    }, i = {
+      client: r(this, _t),
+      meta: this.options.meta,
+      mutationKey: this.options.mutationKey
+    };
+    o(this, gt, Ke({
+      fn: () => this.options.mutationFn ? this.options.mutationFn(t, i) : Promise.reject(new Error("No mutationFn found")),
+      onFail: (w, N) => {
+        v(this, V, Y).call(this, { type: "failed", failureCount: w, error: N });
+      },
+      onPause: () => {
+        v(this, V, Y).call(this, { type: "pause" });
+      },
+      onContinue: s,
+      retry: this.options.retry ?? 0,
+      retryDelay: this.options.retryDelay,
+      networkMode: this.options.networkMode,
+      canRun: () => r(this, A).canRun(this)
+    }));
+    const n = this.state.status === "pending", a = !r(this, gt).canStart();
+    try {
+      if (n)
+        s();
+      else {
+        v(this, V, Y).call(this, { type: "pending", variables: t, isPaused: a }), await ((u = (h = r(this, A).config).onMutate) == null ? void 0 : u.call(
+          h,
+          t,
+          this,
+          i
+        ));
+        const N = await ((b = (d = this.options).onMutate) == null ? void 0 : b.call(
+          d,
+          t,
+          i
+        ));
+        N !== this.state.context && v(this, V, Y).call(this, {
+          type: "pending",
+          context: N,
+          variables: t,
+          isPaused: a
+        });
+      }
+      const w = await r(this, gt).start();
+      return await ((f = (S = r(this, A).config).onSuccess) == null ? void 0 : f.call(
+        S,
+        w,
+        t,
+        this.state.context,
+        this,
+        i
+      )), await ((y = (O = this.options).onSuccess) == null ? void 0 : y.call(
+        O,
+        w,
+        t,
+        this.state.context,
+        i
+      )), await ((p = (R = r(this, A).config).onSettled) == null ? void 0 : p.call(
+        R,
+        w,
+        null,
+        this.state.variables,
+        this.state.context,
+        this,
+        i
+      )), await ((P = (m = this.options).onSettled) == null ? void 0 : P.call(
+        m,
+        w,
+        null,
+        t,
+        this.state.context,
+        i
+      )), v(this, V, Y).call(this, { type: "success", data: w }), w;
+    } catch (w) {
+      try {
+        throw await ((E = (M = r(this, A).config).onError) == null ? void 0 : E.call(
+          M,
+          w,
+          t,
+          this.state.context,
+          this,
+          i
+        )), await ((Q = (l = this.options).onError) == null ? void 0 : Q.call(
+          l,
+          w,
+          t,
+          this.state.context,
+          i
+        )), await ((Z = (x = r(this, A).config).onSettled) == null ? void 0 : Z.call(
+          x,
+          void 0,
+          w,
+          this.state.variables,
+          this.state.context,
+          this,
+          i
+        )), await ((X = (I = this.options).onSettled) == null ? void 0 : X.call(
+          I,
+          void 0,
+          w,
+          t,
+          this.state.context,
+          i
+        )), w;
+      } finally {
+        v(this, V, Y).call(this, { type: "error", error: w });
+      }
+    } finally {
+      r(this, A).runNext(this);
+    }
+  }
+}, _t = new WeakMap(), B = new WeakMap(), A = new WeakMap(), gt = new WeakMap(), V = new WeakSet(), Y = function(t) {
+  const s = (i) => {
+    switch (t.type) {
+      case "failed":
+        return {
+          ...i,
+          failureCount: t.failureCount,
+          failureReason: t.error
+        };
+      case "pause":
+        return {
+          ...i,
+          isPaused: !0
+        };
+      case "continue":
+        return {
+          ...i,
+          isPaused: !1
+        };
+      case "pending":
+        return {
+          ...i,
+          context: t.context,
+          data: void 0,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          isPaused: t.isPaused,
+          status: "pending",
+          variables: t.variables,
+          submittedAt: Date.now()
+        };
+      case "success":
+        return {
+          ...i,
+          data: t.data,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          status: "success",
+          isPaused: !1
+        };
+      case "error":
+        return {
+          ...i,
+          data: void 0,
+          error: t.error,
+          failureCount: i.failureCount + 1,
+          failureReason: t.error,
+          isPaused: !1,
+          status: "error"
+        };
+    }
+  };
+  this.state = s(this.state), T.batch(() => {
+    r(this, B).forEach((i) => {
+      i.onMutationUpdate(t);
+    }), r(this, A).notify({
+      mutation: this,
+      type: "updated",
+      action: t
+    });
+  });
+}, Ae);
+function gs() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+var J, H, kt, xe, bs = (xe = class extends Kt {
+  constructor(t = {}) {
+    super();
+    c(this, J);
+    c(this, H);
+    c(this, kt);
+    this.config = t, o(this, J, /* @__PURE__ */ new Set()), o(this, H, /* @__PURE__ */ new Map()), o(this, kt, 0);
+  }
+  build(t, s, i) {
+    const n = new vs({
+      client: t,
+      mutationCache: this,
+      mutationId: ++Ht(this, kt)._,
+      options: t.defaultMutationOptions(s),
+      state: i
+    });
+    return this.add(n), n;
+  }
+  add(t) {
+    r(this, J).add(t);
+    const s = Gt(t);
+    if (typeof s == "string") {
+      const i = r(this, H).get(s);
+      i ? i.push(t) : r(this, H).set(s, [t]);
+    }
+    this.notify({ type: "added", mutation: t });
+  }
+  remove(t) {
+    if (r(this, J).delete(t)) {
+      const s = Gt(t);
+      if (typeof s == "string") {
+        const i = r(this, H).get(s);
+        if (i)
+          if (i.length > 1) {
+            const n = i.indexOf(t);
+            n !== -1 && i.splice(n, 1);
+          } else i[0] === t && r(this, H).delete(s);
+      }
+    }
+    this.notify({ type: "removed", mutation: t });
+  }
+  canRun(t) {
+    const s = Gt(t);
+    if (typeof s == "string") {
+      const i = r(this, H).get(s), n = i == null ? void 0 : i.find(
+        (a) => a.state.status === "pending"
+      );
+      return !n || n === t;
+    } else
+      return !0;
+  }
+  runNext(t) {
+    var i;
+    const s = Gt(t);
+    if (typeof s == "string") {
+      const n = (i = r(this, H).get(s)) == null ? void 0 : i.find((a) => a !== t && a.state.isPaused);
+      return (n == null ? void 0 : n.continue()) ?? Promise.resolve();
+    } else
+      return Promise.resolve();
+  }
+  clear() {
+    T.batch(() => {
+      r(this, J).forEach((t) => {
+        this.notify({ type: "removed", mutation: t });
+      }), r(this, J).clear(), r(this, H).clear();
+    });
+  }
+  getAll() {
+    return Array.from(r(this, J));
+  }
+  find(t) {
+    const s = { exact: !0, ...t };
+    return this.getAll().find(
+      (i) => ge(s, i)
+    );
+  }
+  findAll(t = {}) {
+    return this.getAll().filter((s) => ge(t, s));
+  }
+  notify(t) {
+    T.batch(() => {
+      this.listeners.forEach((s) => {
+        s(t);
+      });
+    });
+  }
+  resumePausedMutations() {
+    const t = this.getAll().filter((s) => s.state.isPaused);
+    return T.batch(
+      () => Promise.all(
+        t.map((s) => s.continue().catch(j))
+      )
+    );
+  }
+}, J = new WeakMap(), H = new WeakMap(), kt = new WeakMap(), xe);
+function Gt(e) {
+  var t;
+  return (t = e.options.scope) == null ? void 0 : t.id;
+}
+var z, Ue, ws = (Ue = class extends Kt {
+  constructor(t = {}) {
+    super();
+    c(this, z);
+    this.config = t, o(this, z, /* @__PURE__ */ new Map());
+  }
+  build(t, s, i) {
+    const n = s.queryKey, a = s.queryHash ?? le(n, s);
+    let h = this.get(a);
+    return h || (h = new ds({
+      client: t,
+      queryKey: n,
+      queryHash: a,
+      options: t.defaultQueryOptions(s),
+      state: i,
+      defaultOptions: t.getQueryDefaults(n)
+    }), this.add(h)), h;
+  }
+  add(t) {
+    r(this, z).has(t.queryHash) || (r(this, z).set(t.queryHash, t), this.notify({
+      type: "added",
+      query: t
+    }));
+  }
+  remove(t) {
+    const s = r(this, z).get(t.queryHash);
+    s && (t.destroy(), s === t && r(this, z).delete(t.queryHash), this.notify({ type: "removed", query: t }));
+  }
+  clear() {
+    T.batch(() => {
+      this.getAll().forEach((t) => {
+        this.remove(t);
+      });
+    });
+  }
+  get(t) {
+    return r(this, z).get(t);
+  }
+  getAll() {
+    return [...r(this, z).values()];
+  }
+  find(t) {
+    const s = { exact: !0, ...t };
+    return this.getAll().find(
+      (i) => ve(s, i)
+    );
+  }
+  findAll(t = {}) {
+    const s = this.getAll();
+    return Object.keys(t).length > 0 ? s.filter((i) => ve(t, i)) : s;
+  }
+  notify(t) {
+    T.batch(() => {
+      this.listeners.forEach((s) => {
+        s(t);
+      });
+    });
+  }
+  onFocus() {
+    T.batch(() => {
+      this.getAll().forEach((t) => {
+        t.onFocus();
+      });
+    });
+  }
+  onOnline() {
+    T.batch(() => {
+      this.getAll().forEach((t) => {
+        t.onOnline();
+      });
+    });
+  }
+}, z = new WeakMap(), Ue), F, it, nt, Qt, Dt, at, Tt, It, je, Cs = (je = class {
+  constructor(e = {}) {
+    c(this, F);
+    c(this, it);
+    c(this, nt);
+    c(this, Qt);
+    c(this, Dt);
+    c(this, at);
+    c(this, Tt);
+    c(this, It);
+    o(this, F, e.queryCache || new ws()), o(this, it, e.mutationCache || new bs()), o(this, nt, e.defaultOptions || {}), o(this, Qt, /* @__PURE__ */ new Map()), o(this, Dt, /* @__PURE__ */ new Map()), o(this, at, 0);
+  }
+  mount() {
+    Ht(this, at)._++, r(this, at) === 1 && (o(this, Tt, de.subscribe(async (e) => {
+      e && (await this.resumePausedMutations(), r(this, F).onFocus());
+    })), o(this, It, zt.subscribe(async (e) => {
+      e && (await this.resumePausedMutations(), r(this, F).onOnline());
+    })));
+  }
+  unmount() {
+    var e, t;
+    Ht(this, at)._--, r(this, at) === 0 && ((e = r(this, Tt)) == null || e.call(this), o(this, Tt, void 0), (t = r(this, It)) == null || t.call(this), o(this, It, void 0));
+  }
+  isFetching(e) {
+    return r(this, F).findAll({ ...e, fetchStatus: "fetching" }).length;
+  }
+  isMutating(e) {
+    return r(this, it).findAll({ ...e, status: "pending" }).length;
+  }
+  /**
+   * Imperative (non-reactive) way to retrieve data for a QueryKey.
+   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
+   *
+   * Hint: Do not use this function inside a component, because it won't receive updates.
+   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
+   */
+  getQueryData(e) {
+    var s;
+    const t = this.defaultQueryOptions({ queryKey: e });
+    return (s = r(this, F).get(t.queryHash)) == null ? void 0 : s.state.data;
+  }
+  ensureQueryData(e) {
+    const t = this.defaultQueryOptions(e), s = r(this, F).build(this, t), i = s.state.data;
+    return i === void 0 ? this.fetchQuery(e) : (e.revalidateIfStale && s.isStaleByTime(ot(t.staleTime, s)) && this.prefetchQuery(t), Promise.resolve(i));
+  }
+  getQueriesData(e) {
+    return r(this, F).findAll(e).map(({ queryKey: t, state: s }) => {
+      const i = s.data;
+      return [t, i];
+    });
+  }
+  setQueryData(e, t, s) {
+    const i = this.defaultQueryOptions({ queryKey: e }), n = r(this, F).get(
+      i.queryHash
+    ), a = n == null ? void 0 : n.state.data, h = es(t, a);
+    if (h !== void 0)
+      return r(this, F).build(this, i).setData(h, { ...s, manual: !0 });
+  }
+  setQueriesData(e, t, s) {
+    return T.batch(
+      () => r(this, F).findAll(e).map(({ queryKey: i }) => [
+        i,
+        this.setQueryData(i, t, s)
+      ])
+    );
+  }
+  getQueryState(e) {
+    var s;
+    const t = this.defaultQueryOptions({ queryKey: e });
+    return (s = r(this, F).get(
+      t.queryHash
+    )) == null ? void 0 : s.state;
+  }
+  removeQueries(e) {
+    const t = r(this, F);
+    T.batch(() => {
+      t.findAll(e).forEach((s) => {
+        t.remove(s);
+      });
+    });
+  }
+  resetQueries(e, t) {
+    const s = r(this, F);
+    return T.batch(() => (s.findAll(e).forEach((i) => {
+      i.reset();
+    }), this.refetchQueries(
+      {
+        type: "active",
+        ...e
+      },
+      t
+    )));
+  }
+  cancelQueries(e, t = {}) {
+    const s = { revert: !0, ...t }, i = T.batch(
+      () => r(this, F).findAll(e).map((n) => n.cancel(s))
+    );
+    return Promise.all(i).then(j).catch(j);
+  }
+  invalidateQueries(e, t = {}) {
+    return T.batch(() => (r(this, F).findAll(e).forEach((s) => {
+      s.invalidate();
+    }), (e == null ? void 0 : e.refetchType) === "none" ? Promise.resolve() : this.refetchQueries(
+      {
+        ...e,
+        type: (e == null ? void 0 : e.refetchType) ?? (e == null ? void 0 : e.type) ?? "active"
+      },
+      t
+    )));
+  }
+  refetchQueries(e, t = {}) {
+    const s = {
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }, i = T.batch(
+      () => r(this, F).findAll(e).filter((n) => !n.isDisabled() && !n.isStatic()).map((n) => {
+        let a = n.fetch(void 0, s);
+        return s.throwOnError || (a = a.catch(j)), n.state.fetchStatus === "paused" ? Promise.resolve() : a;
+      })
+    );
+    return Promise.all(i).then(j);
+  }
+  fetchQuery(e) {
+    const t = this.defaultQueryOptions(e);
+    t.retry === void 0 && (t.retry = !1);
+    const s = r(this, F).build(this, t);
+    return s.isStaleByTime(
+      ot(t.staleTime, s)
+    ) ? s.fetch(t) : Promise.resolve(s.state.data);
+  }
+  prefetchQuery(e) {
+    return this.fetchQuery(e).then(j).catch(j);
+  }
+  fetchInfiniteQuery(e) {
+    return e.behavior = Ee(e.pages), this.fetchQuery(e);
+  }
+  prefetchInfiniteQuery(e) {
+    return this.fetchInfiniteQuery(e).then(j).catch(j);
+  }
+  ensureInfiniteQueryData(e) {
+    return e.behavior = Ee(e.pages), this.ensureQueryData(e);
+  }
+  resumePausedMutations() {
+    return zt.isOnline() ? r(this, it).resumePausedMutations() : Promise.resolve();
+  }
+  getQueryCache() {
+    return r(this, F);
+  }
+  getMutationCache() {
+    return r(this, it);
+  }
+  getDefaultOptions() {
+    return r(this, nt);
+  }
+  setDefaultOptions(e) {
+    o(this, nt, e);
+  }
+  setQueryDefaults(e, t) {
+    r(this, Qt).set(At(e), {
+      queryKey: e,
+      defaultOptions: t
+    });
+  }
+  getQueryDefaults(e) {
+    const t = [...r(this, Qt).values()], s = {};
+    return t.forEach((i) => {
+      xt(e, i.queryKey) && Object.assign(s, i.defaultOptions);
+    }), s;
+  }
+  setMutationDefaults(e, t) {
+    r(this, Dt).set(At(e), {
+      mutationKey: e,
+      defaultOptions: t
+    });
+  }
+  getMutationDefaults(e) {
+    const t = [...r(this, Dt).values()], s = {};
+    return t.forEach((i) => {
+      xt(e, i.mutationKey) && Object.assign(s, i.defaultOptions);
+    }), s;
+  }
+  defaultQueryOptions(e) {
+    if (e._defaulted)
+      return e;
+    const t = {
+      ...r(this, nt).queries,
+      ...this.getQueryDefaults(e.queryKey),
+      ...e,
+      _defaulted: !0
+    };
+    return t.queryHash || (t.queryHash = le(
+      t.queryKey,
+      t
+    )), t.refetchOnReconnect === void 0 && (t.refetchOnReconnect = t.networkMode !== "always"), t.throwOnError === void 0 && (t.throwOnError = !!t.suspense), !t.networkMode && t.persister && (t.networkMode = "offlineFirst"), t.queryFn === Vt && (t.enabled = !1), t;
+  }
+  defaultMutationOptions(e) {
+    return e != null && e._defaulted ? e : {
+      ...r(this, nt).mutations,
+      ...(e == null ? void 0 : e.mutationKey) && this.getMutationDefaults(e.mutationKey),
+      ...e,
+      _defaulted: !0
+    };
+  }
+  clear() {
+    r(this, F).clear(), r(this, it).clear();
+  }
+}, F = new WeakMap(), it = new WeakMap(), nt = new WeakMap(), Qt = new WeakMap(), Dt = new WeakMap(), at = new WeakMap(), Tt = new WeakMap(), It = new WeakMap(), je), Be = K.createContext(
+  void 0
+), Ss = (e) => {
+  const t = K.useContext(Be);
+  if (!t)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return t;
+}, Os = ({
+  client: e,
+  children: t
+}) => (K.useEffect(() => (e.mount(), () => {
+  e.unmount();
+}), [e]), /* @__PURE__ */ Bt(Be.Provider, { value: e, children: t })), Ve = K.createContext(!1), Ps = () => K.useContext(Ve);
+Ve.Provider;
+function Es() {
+  let e = !1;
+  return {
+    clearReset: () => {
+      e = !1;
+    },
+    reset: () => {
+      e = !0;
+    },
+    isReset: () => e
+  };
+}
+var Fs = K.createContext(Es()), Rs = () => K.useContext(Fs), Ms = (e, t) => {
+  (e.suspense || e.throwOnError || e.experimental_prefetchInRender) && (t.isReset() || (e.retryOnMount = !1));
+}, Qs = (e) => {
+  K.useEffect(() => {
+    e.clearReset();
+  }, [e]);
+}, Ds = ({
+  result: e,
+  errorResetBoundary: t,
+  throwOnError: s,
+  query: i,
+  suspense: n
+}) => e.isError && !t.isReset() && !e.isFetching && i && (n && e.data === void 0 || as(s, [e.error, i])), Ts = (e) => {
+  if (e.suspense) {
+    const s = (n) => n === "static" ? n : Math.max(n ?? 1e3, 1e3), i = e.staleTime;
+    e.staleTime = typeof i == "function" ? (...n) => s(i(...n)) : s(i), typeof e.gcTime == "number" && (e.gcTime = Math.max(
+      e.gcTime,
+      1e3
+    ));
+  }
+}, Is = (e, t) => e.isLoading && e.isFetching && !t, qs = (e, t) => (e == null ? void 0 : e.suspense) && t.isPending, Re = (e, t, s) => t.fetchOptimistic(e).catch(() => {
+  s.clearReset();
+});
+function As(e, t, s) {
+  var f, O, y, R, p;
+  if (process.env.NODE_ENV !== "production" && (typeof e != "object" || Array.isArray(e)))
+    throw new Error(
+      'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+    );
+  const i = Ps(), n = Rs(), a = Ss(), h = a.defaultQueryOptions(e);
+  (O = (f = a.getDefaultOptions().queries) == null ? void 0 : f._experimental_beforeQuery) == null || O.call(
+    f,
+    h
+  ), process.env.NODE_ENV !== "production" && (h.queryFn || console.error(
+    `[${h.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
+  )), h._optimisticResults = i ? "isRestoring" : "optimistic", Ts(h), Ms(h, n), Qs(n);
+  const u = !a.getQueryCache().get(h.queryHash), [d] = K.useState(
+    () => new t(
+      a,
+      h
+    )
+  ), b = d.getOptimisticResult(h), S = !i && e.subscribed !== !1;
+  if (K.useSyncExternalStore(
+    K.useCallback(
+      (m) => {
+        const P = S ? d.subscribe(T.batchCalls(m)) : j;
+        return d.updateResult(), P;
+      },
+      [d, S]
+    ),
+    () => d.getCurrentResult(),
+    () => d.getCurrentResult()
+  ), K.useEffect(() => {
+    d.setOptions(h);
+  }, [h, d]), qs(h, b))
+    throw Re(h, d, n);
+  if (Ds({
+    result: b,
+    errorResetBoundary: n,
+    throwOnError: h.throwOnError,
+    query: a.getQueryCache().get(h.queryHash),
+    suspense: h.suspense
+  }))
+    throw b.error;
+  if ((R = (y = a.getDefaultOptions().queries) == null ? void 0 : y._experimental_afterQuery) == null || R.call(
+    y,
+    h,
+    b
+  ), h.experimental_prefetchInRender && !bt && Is(b, i)) {
+    const m = u ? (
+      // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+      Re(h, d, n)
+    ) : (
+      // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+      (p = a.getQueryCache().get(h.queryHash)) == null ? void 0 : p.promise
+    );
+    m == null || m.catch(j).finally(() => {
+      d.updateResult();
+    });
+  }
+  return h.notifyOnChangeProps ? b : d.trackResult(b);
+}
+function xs(e, t) {
+  return As(e, fs);
+}
+const Us = ze(void 0), js = new Cs({
+  defaultOptions: {
+    queries: {
+      retry: 1,
+      refetchOnWindowFocus: !1,
+      staleTime: 1e3 * 60 * 15
+      // 15 minutes
+    }
+  }
+});
+function Ns({
+  fetchSchedule: e,
+  initialSchedule: t = [],
+  weeks: s,
+  handleDateChanged: i = () => !0,
+  children: n
 }) {
-  const [i, A] = y(a[0][0].date), [n, f] = y(!1), t = v(r), u = x((e) => {
-    f(!0), A(e), o(e);
-  }, [o]);
-  b(() => {
-    let e = !1;
-    typeof r == "object" && !Array.isArray(r) && (r != null && r.queryStatus) ? e = !(typeof t.current == "object" && !Array.isArray(t.current) && "queryStatus" in t.current) : Array.isArray(r) && Array.isArray(t.current) ? e = t.current.length !== r.length || t.current.some((p, C) => {
-      var s;
-      return p.id !== ((s = r[C]) == null ? void 0 : s.id);
-    }) : e = !0, e && n && (f(!1), t.current = r);
-  }, [r, n]);
-  const m = j(() => ({
-    schedule: r,
-    weeks: a,
-    currentDate: i,
-    isLoading: n,
-    setCurrentDate: u
-  }), [r, a, i, n, u]);
-  return /* @__PURE__ */ S(D.Provider, { value: m, children: c });
+  const [a, h] = pe(s[0][0].date), [u, d] = pe(!1), b = $e(Wt(s[0][0].date, "yyyy-MM-dd"));
+  me.setComponent("ScheduleContext"), me.log("fetchSchedule:", e);
+  const S = We((p) => {
+    const m = Wt(p, "yyyy-MM-dd");
+    m !== b.current && (d(!0), b.current = m), h(p), i(p);
+  }, [i]), { data: f, isLoading: O, isError: y } = xs({
+    queryKey: ["schedule", Wt(a, "yyyy-MM-dd")],
+    queryFn: () => e(a),
+    staleTime: 1e3 * 60 * 15,
+    // 15 minutes
+    retry: 1
+  });
+  Je(() => {
+    f !== void 0 && u && d(!1);
+  }, [f, u]);
+  const R = Ze(() => ({
+    schedule: f ?? t,
+    weeks: s,
+    currentDate: a,
+    isLoading: O || u,
+    isError: y,
+    setCurrentDate: S
+  }), [f, t, s, a, O, u, y, S]);
+  return /* @__PURE__ */ Bt(Us.Provider, { value: R, children: n });
+}
+function Gs(e) {
+  return /* @__PURE__ */ Bt(Os, { client: js, children: /* @__PURE__ */ Bt(Ns, { ...e }) });
 }
 export {
-  D as ScheduleContext,
-  L as ScheduleProvider,
-  L as default
+  Us as ScheduleContext,
+  Gs as ScheduleProvider,
+  Gs as default
 };