fastapi-rtk 2.0.1 → 2.0.3

package/dist/.external/esm/@tanstack_query-core@5.100.10/@tanstack/query-core/build/modern/queriesObserver.mjs

@@ -1,224 +0,0 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _client, _result, _queries, _options, _observers, _combinedResult, _lastCombine, _lastResult, _lastQueryHashes, _observerMatches, _QueriesObserver_instances, trackResult_fn, combineResult_fn, shouldSkipCombine_fn, findMatchingObservers_fn, onUpdate_fn, notify_fn, _a;
-import { notifyManager } from "./notifyManager.mjs";
-import { QueryObserver } from "./queryObserver.mjs";
-import { Subscribable } from "./subscribable.mjs";
-import { shallowEqualObjects, replaceEqualDeep } from "./utils.mjs";
-function difference(array1, array2) {
-  const excludeSet = new Set(array2);
-  return array1.filter((x) => !excludeSet.has(x));
-}
-function replaceAt(array, index, value) {
-  const copy = array.slice(0);
-  copy[index] = value;
-  return copy;
-}
-var QueriesObserver = (_a = class extends Subscribable {
-  constructor(client, queries, options) {
-    super();
-    __privateAdd(this, _QueriesObserver_instances);
-    __privateAdd(this, _client);
-    __privateAdd(this, _result);
-    __privateAdd(this, _queries);
-    __privateAdd(this, _options);
-    __privateAdd(this, _observers);
-    __privateAdd(this, _combinedResult);
-    __privateAdd(this, _lastCombine);
-    __privateAdd(this, _lastResult);
-    __privateAdd(this, _lastQueryHashes);
-    __privateAdd(this, _observerMatches, []);
-    __privateSet(this, _client, client);
-    __privateSet(this, _options, options);
-    __privateSet(this, _queries, []);
-    __privateSet(this, _observers, []);
-    __privateSet(this, _result, []);
-    this.setQueries(queries);
-  }
-  onSubscribe() {
-    if (this.listeners.size === 1) {
-      __privateGet(this, _observers).forEach((observer) => {
-        observer.subscribe((result) => {
-          __privateMethod(this, _QueriesObserver_instances, onUpdate_fn).call(this, observer, result);
-        });
-      });
-    }
-  }
-  onUnsubscribe() {
-    if (!this.listeners.size) {
-      this.destroy();
-    }
-  }
-  destroy() {
-    this.listeners = /* @__PURE__ */ new Set();
-    __privateGet(this, _observers).forEach((observer) => {
-      observer.destroy();
-    });
-  }
-  setQueries(queries, options) {
-    __privateSet(this, _queries, queries);
-    __privateSet(this, _options, options);
-    if (process.env.NODE_ENV !== "production") {
-      const queryHashes = queries.map(
-        (query) => __privateGet(this, _client).defaultQueryOptions(query).queryHash
-      );
-      if (new Set(queryHashes).size !== queryHashes.length) {
-        console.warn(
-          "[QueriesObserver]: Duplicate Queries found. This might result in unexpected behavior."
-        );
-      }
-    }
-    notifyManager.batch(() => {
-      const prevObservers = __privateGet(this, _observers);
-      const newObserverMatches = __privateMethod(this, _QueriesObserver_instances, findMatchingObservers_fn).call(this, __privateGet(this, _queries));
-      newObserverMatches.forEach(
-        (match) => match.observer.setOptions(match.defaultedQueryOptions)
-      );
-      const newObservers = newObserverMatches.map((match) => match.observer);
-      const newResult = newObservers.map(
-        (observer) => observer.getCurrentResult()
-      );
-      const hasLengthChange = prevObservers.length !== newObservers.length;
-      const hasIndexChange = newObservers.some(
-        (observer, index) => observer !== prevObservers[index]
-      );
-      const hasStructuralChange = hasLengthChange || hasIndexChange;
-      const hasResultChange = hasStructuralChange ? true : newResult.some((result, index) => {
-        const prev = __privateGet(this, _result)[index];
-        return !prev || !shallowEqualObjects(result, prev);
-      });
-      if (!hasStructuralChange && !hasResultChange) return;
-      if (hasStructuralChange) {
-        __privateSet(this, _observerMatches, newObserverMatches);
-        __privateSet(this, _observers, newObservers);
-      }
-      __privateSet(this, _result, newResult);
-      if (!this.hasListeners()) return;
-      if (hasStructuralChange) {
-        difference(prevObservers, newObservers).forEach((observer) => {
-          observer.destroy();
-        });
-        difference(newObservers, prevObservers).forEach((observer) => {
-          observer.subscribe((result) => {
-            __privateMethod(this, _QueriesObserver_instances, onUpdate_fn).call(this, observer, result);
-          });
-        });
-      }
-      __privateMethod(this, _QueriesObserver_instances, notify_fn).call(this);
-    });
-  }
-  getCurrentResult() {
-    return __privateGet(this, _result);
-  }
-  getQueries() {
-    return __privateGet(this, _observers).map((observer) => observer.getCurrentQuery());
-  }
-  getObservers() {
-    return __privateGet(this, _observers);
-  }
-  getOptimisticResult(queries, combine) {
-    const matches = __privateMethod(this, _QueriesObserver_instances, findMatchingObservers_fn).call(this, queries);
-    const result = matches.map(
-      (match) => match.observer.getOptimisticResult(match.defaultedQueryOptions)
-    );
-    const queryHashes = matches.map(
-      (match) => match.defaultedQueryOptions.queryHash
-    );
-    return [
-      result,
-      (r) => {
-        return __privateMethod(this, _QueriesObserver_instances, combineResult_fn).call(this, r ?? result, combine, queryHashes);
-      },
-      () => {
-        return __privateMethod(this, _QueriesObserver_instances, trackResult_fn).call(this, result, matches);
-      }
-    ];
-  }
-}, _client = new WeakMap(), _result = new WeakMap(), _queries = new WeakMap(), _options = new WeakMap(), _observers = new WeakMap(), _combinedResult = new WeakMap(), _lastCombine = new WeakMap(), _lastResult = new WeakMap(), _lastQueryHashes = new WeakMap(), _observerMatches = new WeakMap(), _QueriesObserver_instances = new WeakSet(), trackResult_fn = function(result, matches) {
-  return matches.map((match, index) => {
-    const observerResult = result[index];
-    return !match.defaultedQueryOptions.notifyOnChangeProps ? match.observer.trackResult(observerResult, (accessedProp) => {
-      matches.forEach((m) => {
-        m.observer.trackProp(accessedProp);
-      });
-    }) : observerResult;
-  });
-}, combineResult_fn = function(input, combine, queryHashes) {
-  if (combine) {
-    const lastHashes = __privateGet(this, _lastQueryHashes);
-    const queryHashesChanged = queryHashes !== void 0 && lastHashes !== void 0 && (lastHashes.length !== queryHashes.length || queryHashes.some((hash, i) => hash !== lastHashes[i]));
-    if (!__privateGet(this, _combinedResult) || __privateGet(this, _result) !== __privateGet(this, _lastResult) || queryHashesChanged || combine !== __privateGet(this, _lastCombine)) {
-      __privateSet(this, _lastCombine, combine);
-      __privateSet(this, _lastResult, __privateGet(this, _result));
-      if (queryHashes !== void 0) {
-        __privateSet(this, _lastQueryHashes, queryHashes);
-      }
-      __privateSet(this, _combinedResult, replaceEqualDeep(
-        __privateGet(this, _combinedResult),
-        combine(input)
-      ));
-    }
-    return __privateGet(this, _combinedResult);
-  }
-  return input;
-}, shouldSkipCombine_fn = function() {
-  var _a2;
-  return ((_a2 = __privateGet(this, _options)) == null ? void 0 : _a2.combine) !== void 0 && __privateGet(this, _observers).some((observer, index) => {
-    var _a3;
-    return observer.options.suspense && ((_a3 = __privateGet(this, _result)[index]) == null ? void 0 : _a3.data) === void 0;
-  });
-}, findMatchingObservers_fn = function(queries) {
-  const prevObserversMap = /* @__PURE__ */ new Map();
-  __privateGet(this, _observers).forEach((observer) => {
-    const key = observer.options.queryHash;
-    if (!key) return;
-    const previousObservers = prevObserversMap.get(key);
-    if (previousObservers) {
-      previousObservers.push(observer);
-    } else {
-      prevObserversMap.set(key, [observer]);
-    }
-  });
-  const observers = [];
-  queries.forEach((options) => {
-    var _a2;
-    const defaultedOptions = __privateGet(this, _client).defaultQueryOptions(options);
-    const match = (_a2 = prevObserversMap.get(defaultedOptions.queryHash)) == null ? void 0 : _a2.shift();
-    const observer = match ?? new QueryObserver(__privateGet(this, _client), defaultedOptions);
-    observers.push({
-      defaultedQueryOptions: defaultedOptions,
-      observer
-    });
-  });
-  return observers;
-}, onUpdate_fn = function(observer, result) {
-  const index = __privateGet(this, _observers).indexOf(observer);
-  if (index !== -1) {
-    __privateSet(this, _result, replaceAt(__privateGet(this, _result), index, result));
-    __privateMethod(this, _QueriesObserver_instances, notify_fn).call(this);
-  }
-}, notify_fn = function() {
-  var _a2;
-  if (this.hasListeners()) {
-    const newTracked = __privateMethod(this, _QueriesObserver_instances, trackResult_fn).call(this, __privateGet(this, _result), __privateGet(this, _observerMatches));
-    const shouldSkipCombine = __privateMethod(this, _QueriesObserver_instances, shouldSkipCombine_fn).call(this);
-    const previousResult = __privateGet(this, _combinedResult);
-    const newResult = shouldSkipCombine ? previousResult : __privateMethod(this, _QueriesObserver_instances, combineResult_fn).call(this, newTracked, (_a2 = __privateGet(this, _options)) == null ? void 0 : _a2.combine);
-    if (shouldSkipCombine || previousResult !== newResult) {
-      notifyManager.batch(() => {
-        this.listeners.forEach((listener) => {
-          listener(__privateGet(this, _result));
-        });
-      });
-    }
-  }
-}, _a);
-export {
-  QueriesObserver
-};

package/dist/.external/esm/@tanstack_query-core@5.100.10/@tanstack/query-core/build/modern/query.mjs

@@ -1,460 +0,0 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _queryType, _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _Query_instances, isInitialPausedFetch_fn, dispatch_fn, _a;
-import { replaceData, noop, resolveQueryBoolean, skipToken, resolveStaleTime, timeUntilStale, ensureQueryFn } from "./utils.mjs";
-import { notifyManager } from "./notifyManager.mjs";
-import { createRetryer, CancelledError, canFetch } from "./retryer.mjs";
-import { Removable } from "./removable.mjs";
-import { infiniteQueryBehavior } from "./infiniteQueryBehavior.mjs";
-var Query = (_a = class extends Removable {
-  constructor(config) {
-    super();
-    __privateAdd(this, _Query_instances);
-    __privateAdd(this, _queryType);
-    __privateAdd(this, _initialState);
-    __privateAdd(this, _revertState);
-    __privateAdd(this, _cache);
-    __privateAdd(this, _client);
-    __privateAdd(this, _retryer);
-    __privateAdd(this, _defaultOptions);
-    __privateAdd(this, _abortSignalConsumed);
-    __privateSet(this, _abortSignalConsumed, false);
-    __privateSet(this, _defaultOptions, config.defaultOptions);
-    this.setOptions(config.options);
-    this.observers = [];
-    __privateSet(this, _client, config.client);
-    __privateSet(this, _cache, __privateGet(this, _client).getQueryCache());
-    this.queryKey = config.queryKey;
-    this.queryHash = config.queryHash;
-    __privateSet(this, _initialState, getDefaultState(this.options));
-    this.state = config.state ?? __privateGet(this, _initialState);
-    this.scheduleGc();
-  }
-  get meta() {
-    return this.options.meta;
-  }
-  get queryType() {
-    return __privateGet(this, _queryType);
-  }
-  get promise() {
-    var _a2;
-    return (_a2 = __privateGet(this, _retryer)) == null ? void 0 : _a2.promise;
-  }
-  setOptions(options) {
-    this.options = { ...__privateGet(this, _defaultOptions), ...options };
-    if (options == null ? void 0 : options._type) {
-      __privateSet(this, _queryType, options._type);
-    }
-    this.updateGcTime(this.options.gcTime);
-    if (this.state && this.state.data === void 0) {
-      const defaultState = getDefaultState(this.options);
-      if (defaultState.data !== void 0) {
-        this.setState(
-          successState(defaultState.data, defaultState.dataUpdatedAt)
-        );
-        __privateSet(this, _initialState, defaultState);
-      }
-    }
-  }
-  optionalRemove() {
-    if (!this.observers.length && this.state.fetchStatus === "idle") {
-      __privateGet(this, _cache).remove(this);
-    }
-  }
-  setData(newData, options) {
-    const data = replaceData(this.state.data, newData, this.options);
-    __privateMethod(this, _Query_instances, dispatch_fn).call(this, {
-      data,
-      type: "success",
-      dataUpdatedAt: options == null ? void 0 : options.updatedAt,
-      manual: options == null ? void 0 : options.manual
-    });
-    return data;
-  }
-  setState(state) {
-    __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "setState", state });
-  }
-  cancel(options) {
-    var _a2, _b;
-    const promise = (_a2 = __privateGet(this, _retryer)) == null ? void 0 : _a2.promise;
-    (_b = __privateGet(this, _retryer)) == null ? void 0 : _b.cancel(options);
-    return promise ? promise.then(noop).catch(noop) : Promise.resolve();
-  }
-  destroy() {
-    super.destroy();
-    this.cancel({ silent: true });
-  }
-  get resetState() {
-    return __privateGet(this, _initialState);
-  }
-  reset() {
-    this.destroy();
-    this.setState(this.resetState);
-  }
-  isActive() {
-    return this.observers.some(
-      (observer) => resolveQueryBoolean(observer.options.enabled, this) !== false
-    );
-  }
-  isDisabled() {
-    if (this.getObserversCount() > 0) {
-      return !this.isActive();
-    }
-    return this.options.queryFn === skipToken || !this.isFetched();
-  }
-  isFetched() {
-    return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
-  }
-  isStatic() {
-    if (this.getObserversCount() > 0) {
-      return this.observers.some(
-        (observer) => resolveStaleTime(observer.options.staleTime, this) === "static"
-      );
-    }
-    return false;
-  }
-  isStale() {
-    if (this.getObserversCount() > 0) {
-      return this.observers.some(
-        (observer) => observer.getCurrentResult().isStale
-      );
-    }
-    return this.state.data === void 0 || this.state.isInvalidated;
-  }
-  isStaleByTime(staleTime = 0) {
-    if (this.state.data === void 0) {
-      return true;
-    }
-    if (staleTime === "static") {
-      return false;
-    }
-    if (this.state.isInvalidated) {
-      return true;
-    }
-    return !timeUntilStale(this.state.dataUpdatedAt, staleTime);
-  }
-  onFocus() {
-    var _a2;
-    const observer = this.observers.find((x) => x.shouldFetchOnWindowFocus());
-    observer == null ? void 0 : observer.refetch({ cancelRefetch: false });
-    (_a2 = __privateGet(this, _retryer)) == null ? void 0 : _a2.continue();
-  }
-  onOnline() {
-    var _a2;
-    const observer = this.observers.find((x) => x.shouldFetchOnReconnect());
-    observer == null ? void 0 : observer.refetch({ cancelRefetch: false });
-    (_a2 = __privateGet(this, _retryer)) == null ? void 0 : _a2.continue();
-  }
-  addObserver(observer) {
-    if (!this.observers.includes(observer)) {
-      this.observers.push(observer);
-      this.clearGcTimeout();
-      __privateGet(this, _cache).notify({ type: "observerAdded", query: this, observer });
-    }
-  }
-  removeObserver(observer) {
-    if (this.observers.includes(observer)) {
-      this.observers = this.observers.filter((x) => x !== observer);
-      if (!this.observers.length) {
-        if (__privateGet(this, _retryer)) {
-          if (__privateGet(this, _abortSignalConsumed) || __privateMethod(this, _Query_instances, isInitialPausedFetch_fn).call(this)) {
-            __privateGet(this, _retryer).cancel({ revert: true });
-          } else {
-            __privateGet(this, _retryer).cancelRetry();
-          }
-        }
-        this.scheduleGc();
-      }
-      __privateGet(this, _cache).notify({ type: "observerRemoved", query: this, observer });
-    }
-  }
-  getObserversCount() {
-    return this.observers.length;
-  }
-  invalidate() {
-    if (!this.state.isInvalidated) {
-      __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "invalidate" });
-    }
-  }
-  async fetch(options, fetchOptions) {
-    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
-    if (this.state.fetchStatus !== "idle" && // If the promise in the retryer 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
-    ((_a2 = __privateGet(this, _retryer)) == null ? void 0 : _a2.status()) !== "rejected") {
-      if (this.state.data !== void 0 && (fetchOptions == null ? void 0 : fetchOptions.cancelRefetch)) {
-        this.cancel({ silent: true });
-      } else if (__privateGet(this, _retryer)) {
-        __privateGet(this, _retryer).continueRetry();
-        return __privateGet(this, _retryer).promise;
-      }
-    }
-    if (options) {
-      this.setOptions(options);
-    }
-    if (!this.options.queryFn) {
-      const observer = this.observers.find((x) => x.options.queryFn);
-      if (observer) {
-        this.setOptions(observer.options);
-      }
-    }
-    if (process.env.NODE_ENV !== "production") {
-      if (!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 abortController = new AbortController();
-    const addSignalProperty = (object) => {
-      Object.defineProperty(object, "signal", {
-        enumerable: true,
-        get: () => {
-          __privateSet(this, _abortSignalConsumed, true);
-          return abortController.signal;
-        }
-      });
-    };
-    const fetchFn = () => {
-      const queryFn = ensureQueryFn(this.options, fetchOptions);
-      const createQueryFnContext = () => {
-        const queryFnContext2 = {
-          client: __privateGet(this, _client),
-          queryKey: this.queryKey,
-          meta: this.meta
-        };
-        addSignalProperty(queryFnContext2);
-        return queryFnContext2;
-      };
-      const queryFnContext = createQueryFnContext();
-      __privateSet(this, _abortSignalConsumed, false);
-      if (this.options.persister) {
-        return this.options.persister(
-          queryFn,
-          queryFnContext,
-          this
-        );
-      }
-      return queryFn(queryFnContext);
-    };
-    const createFetchContext = () => {
-      const context2 = {
-        fetchOptions,
-        options: this.options,
-        queryKey: this.queryKey,
-        client: __privateGet(this, _client),
-        state: this.state,
-        fetchFn
-      };
-      addSignalProperty(context2);
-      return context2;
-    };
-    const context = createFetchContext();
-    const behavior = __privateGet(this, _queryType) === "infinite" ? infiniteQueryBehavior(
-      this.options.pages
-    ) : this.options.behavior;
-    behavior == null ? void 0 : behavior.onFetch(context, this);
-    __privateSet(this, _revertState, this.state);
-    if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((_b = context.fetchOptions) == null ? void 0 : _b.meta)) {
-      __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "fetch", meta: (_c = context.fetchOptions) == null ? void 0 : _c.meta });
-    }
-    __privateSet(this, _retryer, createRetryer({
-      initialPromise: fetchOptions == null ? void 0 : fetchOptions.initialPromise,
-      fn: context.fetchFn,
-      onCancel: (error) => {
-        if (error instanceof CancelledError && error.revert) {
-          this.setState({
-            ...__privateGet(this, _revertState),
-            fetchStatus: "idle"
-          });
-        }
-        abortController.abort();
-      },
-      onFail: (failureCount, error) => {
-        __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "failed", failureCount, error });
-      },
-      onPause: () => {
-        __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "pause" });
-      },
-      onContinue: () => {
-        __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "continue" });
-      },
-      retry: context.options.retry,
-      retryDelay: context.options.retryDelay,
-      networkMode: context.options.networkMode,
-      canRun: () => true
-    }));
-    try {
-      const data = await __privateGet(this, _retryer).start();
-      if (data === void 0) {
-        if (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}`
-          );
-        }
-        throw new Error(`${this.queryHash} data is undefined`);
-      }
-      this.setData(data);
-      (_e = (_d = __privateGet(this, _cache).config).onSuccess) == null ? void 0 : _e.call(_d, data, this);
-      (_g = (_f = __privateGet(this, _cache).config).onSettled) == null ? void 0 : _g.call(
-        _f,
-        data,
-        this.state.error,
-        this
-      );
-      return data;
-    } catch (error) {
-      if (error instanceof CancelledError) {
-        if (error.silent) {
-          return __privateGet(this, _retryer).promise;
-        } else if (error.revert) {
-          if (this.state.data === void 0) {
-            throw error;
-          }
-          return this.state.data;
-        }
-      }
-      __privateMethod(this, _Query_instances, dispatch_fn).call(this, {
-        type: "error",
-        error
-      });
-      (_i = (_h = __privateGet(this, _cache).config).onError) == null ? void 0 : _i.call(
-        _h,
-        error,
-        this
-      );
-      (_k = (_j = __privateGet(this, _cache).config).onSettled) == null ? void 0 : _k.call(
-        _j,
-        this.state.data,
-        error,
-        this
-      );
-      throw error;
-    } finally {
-      this.scheduleGc();
-    }
-  }
-}, _queryType = new WeakMap(), _initialState = new WeakMap(), _revertState = new WeakMap(), _cache = new WeakMap(), _client = new WeakMap(), _retryer = new WeakMap(), _defaultOptions = new WeakMap(), _abortSignalConsumed = new WeakMap(), _Query_instances = new WeakSet(), isInitialPausedFetch_fn = function() {
-  return this.state.fetchStatus === "paused" && this.state.status === "pending";
-}, dispatch_fn = function(action) {
-  const reducer = (state) => {
-    switch (action.type) {
-      case "failed":
-        return {
-          ...state,
-          fetchFailureCount: action.failureCount,
-          fetchFailureReason: action.error
-        };
-      case "pause":
-        return {
-          ...state,
-          fetchStatus: "paused"
-        };
-      case "continue":
-        return {
-          ...state,
-          fetchStatus: "fetching"
-        };
-      case "fetch":
-        return {
-          ...state,
-          ...fetchState(state.data, this.options),
-          fetchMeta: action.meta ?? null
-        };
-      case "success":
-        const newState = {
-          ...state,
-          ...successState(action.data, action.dataUpdatedAt),
-          dataUpdateCount: state.dataUpdateCount + 1,
-          ...!action.manual && {
-            fetchStatus: "idle",
-            fetchFailureCount: 0,
-            fetchFailureReason: null
-          }
-        };
-        __privateSet(this, _revertState, action.manual ? newState : void 0);
-        return newState;
-      case "error":
-        const error = action.error;
-        return {
-          ...state,
-          error,
-          errorUpdateCount: state.errorUpdateCount + 1,
-          errorUpdatedAt: Date.now(),
-          fetchFailureCount: state.fetchFailureCount + 1,
-          fetchFailureReason: error,
-          fetchStatus: "idle",
-          status: "error",
-          // flag existing data as invalidated if we get a background error
-          // note that "no data" always means stale so we can set unconditionally here
-          isInvalidated: true
-        };
-      case "invalidate":
-        return {
-          ...state,
-          isInvalidated: true
-        };
-      case "setState":
-        return {
-          ...state,
-          ...action.state
-        };
-    }
-  };
-  this.state = reducer(this.state);
-  notifyManager.batch(() => {
-    this.observers.forEach((observer) => {
-      observer.onQueryUpdate();
-    });
-    __privateGet(this, _cache).notify({ query: this, type: "updated", action });
-  });
-}, _a);
-function fetchState(data, options) {
-  return {
-    fetchFailureCount: 0,
-    fetchFailureReason: null,
-    fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
-    ...data === void 0 && {
-      error: null,
-      status: "pending"
-    }
-  };
-}
-function successState(data, dataUpdatedAt) {
-  return {
-    data,
-    dataUpdatedAt: dataUpdatedAt ?? Date.now(),
-    error: null,
-    isInvalidated: false,
-    status: "success"
-  };
-}
-function getDefaultState(options) {
-  const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
-  const hasData = data !== void 0;
-  const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
-  return {
-    data,
-    dataUpdateCount: 0,
-    dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
-    error: null,
-    errorUpdateCount: 0,
-    errorUpdatedAt: 0,
-    fetchFailureCount: 0,
-    fetchFailureReason: null,
-    fetchMeta: null,
-    isInvalidated: false,
-    status: hasData ? "success" : "pending",
-    fetchStatus: "idle"
-  };
-}
-export {
-  Query,
-  fetchState
-};