@ventlio/tanstack-query 0.5.6 → 0.5.8

package/dist/index.mjs

@@ -1,40 +1,716 @@
 import 'url-search-params-polyfill';
-import { useQueryClient, useQuery, useInfiniteQuery, useMutation } from '@tanstack/react-query';
+import require$$0, { useState, useEffect, useMemo, startTransition } from 'react';
 import { create } from 'zustand';
-import { useState, useEffect, useMemo, startTransition } from 'react';
+import { useQueryClient, useQuery, useInfiniteQuery, useMutation } from '@tanstack/react-query';
 import result from 'lodash.result';
 import lodashSet from 'lodash.set';
 import axios from 'axios';
 
-const bootstrapQueryRequest = (queryClient, options) => {
-    // make query config doesn't expire
-    // set default query config
-    const defaultMeta = {
-        headers: {
-            Authorization: ``,
-        },
-        options,
-    };
-    queryClient.setDefaultOptions({
-        queries: {
-            meta: defaultMeta,
-        },
-        mutations: { meta: defaultMeta },
-    });
+var withSelectorExports = {};
+var withSelector = {
+  get exports(){ return withSelectorExports; },
+  set exports(v){ withSelectorExports = v; },
 };
 
-const useQueryConfig = () => {
-    const queryClient = useQueryClient();
-    const mutationMeta = (queryClient.getDefaultOptions().mutations?.meta ?? {});
-    const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {});
-    return { ...queryMeta, ...mutationMeta };
+var withSelector_production = {};
+
+var shimExports = {};
+var shim = {
+  get exports(){ return shimExports; },
+  set exports(v){ shimExports = v; },
+};
+
+var useSyncExternalStoreShim_production = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_production;
+
+function requireUseSyncExternalStoreShim_production () {
+	if (hasRequiredUseSyncExternalStoreShim_production) return useSyncExternalStoreShim_production;
+	hasRequiredUseSyncExternalStoreShim_production = 1;
+	var React = require$$0;
+	function is(x, y) {
+	  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+	}
+	var objectIs = "function" === typeof Object.is ? Object.is : is,
+	  useState = React.useState,
+	  useEffect = React.useEffect,
+	  useLayoutEffect = React.useLayoutEffect,
+	  useDebugValue = React.useDebugValue;
+	function useSyncExternalStore$2(subscribe, getSnapshot) {
+	  var value = getSnapshot(),
+	    _useState = useState({ inst: { value: value, getSnapshot: getSnapshot } }),
+	    inst = _useState[0].inst,
+	    forceUpdate = _useState[1];
+	  useLayoutEffect(
+	    function () {
+	      inst.value = value;
+	      inst.getSnapshot = getSnapshot;
+	      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	    },
+	    [subscribe, value, getSnapshot]
+	  );
+	  useEffect(
+	    function () {
+	      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	      return subscribe(function () {
+	        checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	      });
+	    },
+	    [subscribe]
+	  );
+	  useDebugValue(value);
+	  return value;
+	}
+	function checkIfSnapshotChanged(inst) {
+	  var latestGetSnapshot = inst.getSnapshot;
+	  inst = inst.value;
+	  try {
+	    var nextValue = latestGetSnapshot();
+	    return !objectIs(inst, nextValue);
+	  } catch (error) {
+	    return !0;
+	  }
+	}
+	function useSyncExternalStore$1(subscribe, getSnapshot) {
+	  return getSnapshot();
+	}
+	var shim =
+	  "undefined" === typeof window ||
+	  "undefined" === typeof window.document ||
+	  "undefined" === typeof window.document.createElement
+	    ? useSyncExternalStore$1
+	    : useSyncExternalStore$2;
+	useSyncExternalStoreShim_production.useSyncExternalStore =
+	  void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+	return useSyncExternalStoreShim_production;
+}
+
+var useSyncExternalStoreShim_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_development;
+
+function requireUseSyncExternalStoreShim_development () {
+	if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+	hasRequiredUseSyncExternalStoreShim_development = 1;
+	"production" !== process.env.NODE_ENV &&
+	  (function () {
+	    function is(x, y) {
+	      return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+	    }
+	    function useSyncExternalStore$2(subscribe, getSnapshot) {
+	      didWarnOld18Alpha ||
+	        void 0 === React.startTransition ||
+	        ((didWarnOld18Alpha = !0),
+	        console.error(
+	          "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+	        ));
+	      var value = getSnapshot();
+	      if (!didWarnUncachedGetSnapshot) {
+	        var cachedValue = getSnapshot();
+	        objectIs(value, cachedValue) ||
+	          (console.error(
+	            "The result of getSnapshot should be cached to avoid an infinite loop"
+	          ),
+	          (didWarnUncachedGetSnapshot = !0));
+	      }
+	      cachedValue = useState({
+	        inst: { value: value, getSnapshot: getSnapshot }
+	      });
+	      var inst = cachedValue[0].inst,
+	        forceUpdate = cachedValue[1];
+	      useLayoutEffect(
+	        function () {
+	          inst.value = value;
+	          inst.getSnapshot = getSnapshot;
+	          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	        },
+	        [subscribe, value, getSnapshot]
+	      );
+	      useEffect(
+	        function () {
+	          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	          return subscribe(function () {
+	            checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	          });
+	        },
+	        [subscribe]
+	      );
+	      useDebugValue(value);
+	      return value;
+	    }
+	    function checkIfSnapshotChanged(inst) {
+	      var latestGetSnapshot = inst.getSnapshot;
+	      inst = inst.value;
+	      try {
+	        var nextValue = latestGetSnapshot();
+	        return !objectIs(inst, nextValue);
+	      } catch (error) {
+	        return !0;
+	      }
+	    }
+	    function useSyncExternalStore$1(subscribe, getSnapshot) {
+	      return getSnapshot();
+	    }
+	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+	      "function" ===
+	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
+	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+	    var React = require$$0,
+	      objectIs = "function" === typeof Object.is ? Object.is : is,
+	      useState = React.useState,
+	      useEffect = React.useEffect,
+	      useLayoutEffect = React.useLayoutEffect,
+	      useDebugValue = React.useDebugValue,
+	      didWarnOld18Alpha = !1,
+	      didWarnUncachedGetSnapshot = !1,
+	      shim =
+	        "undefined" === typeof window ||
+	        "undefined" === typeof window.document ||
+	        "undefined" === typeof window.document.createElement
+	          ? useSyncExternalStore$1
+	          : useSyncExternalStore$2;
+	    useSyncExternalStoreShim_development.useSyncExternalStore =
+	      void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+	      "function" ===
+	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
+	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+	  })();
+	return useSyncExternalStoreShim_development;
+}
+
+var hasRequiredShim;
+
+function requireShim () {
+	if (hasRequiredShim) return shimExports;
+	hasRequiredShim = 1;
+	(function (module) {
+
+		if (process.env.NODE_ENV === 'production') {
+		  module.exports = requireUseSyncExternalStoreShim_production();
+		} else {
+		  module.exports = requireUseSyncExternalStoreShim_development();
+		}
+} (shim));
+	return shimExports;
+}
+
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredWithSelector_production;
+
+function requireWithSelector_production () {
+	if (hasRequiredWithSelector_production) return withSelector_production;
+	hasRequiredWithSelector_production = 1;
+	var React = require$$0,
+	  shim = requireShim();
+	function is(x, y) {
+	  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+	}
+	var objectIs = "function" === typeof Object.is ? Object.is : is,
+	  useSyncExternalStore = shim.useSyncExternalStore,
+	  useRef = React.useRef,
+	  useEffect = React.useEffect,
+	  useMemo = React.useMemo,
+	  useDebugValue = React.useDebugValue;
+	withSelector_production.useSyncExternalStoreWithSelector = function (
+	  subscribe,
+	  getSnapshot,
+	  getServerSnapshot,
+	  selector,
+	  isEqual
+	) {
+	  var instRef = useRef(null);
+	  if (null === instRef.current) {
+	    var inst = { hasValue: !1, value: null };
+	    instRef.current = inst;
+	  } else inst = instRef.current;
+	  instRef = useMemo(
+	    function () {
+	      function memoizedSelector(nextSnapshot) {
+	        if (!hasMemo) {
+	          hasMemo = !0;
+	          memoizedSnapshot = nextSnapshot;
+	          nextSnapshot = selector(nextSnapshot);
+	          if (void 0 !== isEqual && inst.hasValue) {
+	            var currentSelection = inst.value;
+	            if (isEqual(currentSelection, nextSnapshot))
+	              return (memoizedSelection = currentSelection);
+	          }
+	          return (memoizedSelection = nextSnapshot);
+	        }
+	        currentSelection = memoizedSelection;
+	        if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+	        var nextSelection = selector(nextSnapshot);
+	        if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+	          return (memoizedSnapshot = nextSnapshot), currentSelection;
+	        memoizedSnapshot = nextSnapshot;
+	        return (memoizedSelection = nextSelection);
+	      }
+	      var hasMemo = !1,
+	        memoizedSnapshot,
+	        memoizedSelection,
+	        maybeGetServerSnapshot =
+	          void 0 === getServerSnapshot ? null : getServerSnapshot;
+	      return [
+	        function () {
+	          return memoizedSelector(getSnapshot());
+	        },
+	        null === maybeGetServerSnapshot
+	          ? void 0
+	          : function () {
+	              return memoizedSelector(maybeGetServerSnapshot());
+	            }
+	      ];
+	    },
+	    [getSnapshot, getServerSnapshot, selector, isEqual]
+	  );
+	  var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+	  useEffect(
+	    function () {
+	      inst.hasValue = !0;
+	      inst.value = value;
+	    },
+	    [value]
+	  );
+	  useDebugValue(value);
+	  return value;
+	};
+	return withSelector_production;
+}
+
+var withSelector_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredWithSelector_development;
+
+function requireWithSelector_development () {
+	if (hasRequiredWithSelector_development) return withSelector_development;
+	hasRequiredWithSelector_development = 1;
+	"production" !== process.env.NODE_ENV &&
+	  (function () {
+	    function is(x, y) {
+	      return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+	    }
+	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+	      "function" ===
+	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
+	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+	    var React = require$$0,
+	      shim = requireShim(),
+	      objectIs = "function" === typeof Object.is ? Object.is : is,
+	      useSyncExternalStore = shim.useSyncExternalStore,
+	      useRef = React.useRef,
+	      useEffect = React.useEffect,
+	      useMemo = React.useMemo,
+	      useDebugValue = React.useDebugValue;
+	    withSelector_development.useSyncExternalStoreWithSelector = function (
+	      subscribe,
+	      getSnapshot,
+	      getServerSnapshot,
+	      selector,
+	      isEqual
+	    ) {
+	      var instRef = useRef(null);
+	      if (null === instRef.current) {
+	        var inst = { hasValue: !1, value: null };
+	        instRef.current = inst;
+	      } else inst = instRef.current;
+	      instRef = useMemo(
+	        function () {
+	          function memoizedSelector(nextSnapshot) {
+	            if (!hasMemo) {
+	              hasMemo = !0;
+	              memoizedSnapshot = nextSnapshot;
+	              nextSnapshot = selector(nextSnapshot);
+	              if (void 0 !== isEqual && inst.hasValue) {
+	                var currentSelection = inst.value;
+	                if (isEqual(currentSelection, nextSnapshot))
+	                  return (memoizedSelection = currentSelection);
+	              }
+	              return (memoizedSelection = nextSnapshot);
+	            }
+	            currentSelection = memoizedSelection;
+	            if (objectIs(memoizedSnapshot, nextSnapshot))
+	              return currentSelection;
+	            var nextSelection = selector(nextSnapshot);
+	            if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+	              return (memoizedSnapshot = nextSnapshot), currentSelection;
+	            memoizedSnapshot = nextSnapshot;
+	            return (memoizedSelection = nextSelection);
+	          }
+	          var hasMemo = !1,
+	            memoizedSnapshot,
+	            memoizedSelection,
+	            maybeGetServerSnapshot =
+	              void 0 === getServerSnapshot ? null : getServerSnapshot;
+	          return [
+	            function () {
+	              return memoizedSelector(getSnapshot());
+	            },
+	            null === maybeGetServerSnapshot
+	              ? void 0
+	              : function () {
+	                  return memoizedSelector(maybeGetServerSnapshot());
+	                }
+	          ];
+	        },
+	        [getSnapshot, getServerSnapshot, selector, isEqual]
+	      );
+	      var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+	      useEffect(
+	        function () {
+	          inst.hasValue = !0;
+	          inst.value = value;
+	        },
+	        [value]
+	      );
+	      useDebugValue(value);
+	      return value;
+	    };
+	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+	      "function" ===
+	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
+	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+	  })();
+	return withSelector_development;
+}
+
+(function (module) {
+
+	if (process.env.NODE_ENV === 'production') {
+	  module.exports = requireWithSelector_production();
+	} else {
+	  module.exports = requireWithSelector_development();
+	}
+} (withSelector));
+
+const __storeToDerived = /* @__PURE__ */ new WeakMap();
+const __derivedToStore = /* @__PURE__ */ new WeakMap();
+const __depsThatHaveWrittenThisTick = {
+  current: []
+};
+let __isFlushing = false;
+let __batchDepth = 0;
+const __pendingUpdates = /* @__PURE__ */ new Set();
+const __initialBatchValues = /* @__PURE__ */ new Map();
+function __flush_internals(relatedVals) {
+  const sorted = Array.from(relatedVals).sort((a, b) => {
+    if (a instanceof Derived && a.options.deps.includes(b)) return 1;
+    if (b instanceof Derived && b.options.deps.includes(a)) return -1;
+    return 0;
+  });
+  for (const derived of sorted) {
+    if (__depsThatHaveWrittenThisTick.current.includes(derived)) {
+      continue;
+    }
+    __depsThatHaveWrittenThisTick.current.push(derived);
+    derived.recompute();
+    const stores = __derivedToStore.get(derived);
+    if (stores) {
+      for (const store of stores) {
+        const relatedLinkedDerivedVals = __storeToDerived.get(store);
+        if (!relatedLinkedDerivedVals) continue;
+        __flush_internals(relatedLinkedDerivedVals);
+      }
+    }
+  }
+}
+function __notifyListeners(store) {
+  store.listeners.forEach(
+    (listener) => listener({
+      prevVal: store.prevState,
+      currentVal: store.state
+    })
+  );
+}
+function __notifyDerivedListeners(derived) {
+  derived.listeners.forEach(
+    (listener) => listener({
+      prevVal: derived.prevState,
+      currentVal: derived.state
+    })
+  );
+}
+function __flush(store) {
+  if (__batchDepth > 0 && !__initialBatchValues.has(store)) {
+    __initialBatchValues.set(store, store.prevState);
+  }
+  __pendingUpdates.add(store);
+  if (__isFlushing) return;
+  try {
+    __isFlushing = true;
+    while (__pendingUpdates.size > 0) {
+      const stores = Array.from(__pendingUpdates);
+      __pendingUpdates.clear();
+      for (const store2 of stores) {
+        const prevState = __initialBatchValues.get(store2) ?? store2.prevState;
+        store2.prevState = prevState;
+        __notifyListeners(store2);
+      }
+      for (const store2 of stores) {
+        const derivedVals = __storeToDerived.get(store2);
+        if (!derivedVals) continue;
+        __depsThatHaveWrittenThisTick.current.push(store2);
+        __flush_internals(derivedVals);
+      }
+      for (const store2 of stores) {
+        const derivedVals = __storeToDerived.get(store2);
+        if (!derivedVals) continue;
+        for (const derived of derivedVals) {
+          __notifyDerivedListeners(derived);
+        }
+      }
+    }
+  } finally {
+    __isFlushing = false;
+    __depsThatHaveWrittenThisTick.current = [];
+    __initialBatchValues.clear();
+  }
+}
+
+class Store {
+  constructor(initialState, options) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (listener) => {
+      var _a, _b;
+      this.listeners.add(listener);
+      const unsub = (_b = (_a = this.options) == null ? void 0 : _a.onSubscribe) == null ? void 0 : _b.call(_a, listener, this);
+      return () => {
+        this.listeners.delete(listener);
+        unsub == null ? void 0 : unsub();
+      };
+    };
+    this.setState = (updater) => {
+      var _a, _b, _c;
+      this.prevState = this.state;
+      this.state = ((_a = this.options) == null ? void 0 : _a.updateFn) ? this.options.updateFn(this.prevState)(updater) : updater(this.prevState);
+      (_c = (_b = this.options) == null ? void 0 : _b.onUpdate) == null ? void 0 : _c.call(_b);
+      __flush(this);
+    };
+    this.prevState = initialState;
+    this.state = initialState;
+    this.options = options;
+  }
+}
+
+class Derived {
+  constructor(options) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this._subscriptions = [];
+    this.lastSeenDepValues = [];
+    this.getDepVals = () => {
+      const prevDepVals = [];
+      const currDepVals = [];
+      for (const dep of this.options.deps) {
+        prevDepVals.push(dep.prevState);
+        currDepVals.push(dep.state);
+      }
+      this.lastSeenDepValues = currDepVals;
+      return {
+        prevDepVals,
+        currDepVals,
+        prevVal: this.prevState ?? void 0
+      };
+    };
+    this.recompute = () => {
+      var _a, _b;
+      this.prevState = this.state;
+      const { prevDepVals, currDepVals, prevVal } = this.getDepVals();
+      this.state = this.options.fn({
+        prevDepVals,
+        currDepVals,
+        prevVal
+      });
+      (_b = (_a = this.options).onUpdate) == null ? void 0 : _b.call(_a);
+    };
+    this.checkIfRecalculationNeededDeeply = () => {
+      for (const dep of this.options.deps) {
+        if (dep instanceof Derived) {
+          dep.checkIfRecalculationNeededDeeply();
+        }
+      }
+      let shouldRecompute = false;
+      const lastSeenDepValues = this.lastSeenDepValues;
+      const { currDepVals } = this.getDepVals();
+      for (let i = 0; i < currDepVals.length; i++) {
+        if (currDepVals[i] !== lastSeenDepValues[i]) {
+          shouldRecompute = true;
+          break;
+        }
+      }
+      if (shouldRecompute) {
+        this.recompute();
+      }
+    };
+    this.mount = () => {
+      this.registerOnGraph();
+      this.checkIfRecalculationNeededDeeply();
+      return () => {
+        this.unregisterFromGraph();
+        for (const cleanup of this._subscriptions) {
+          cleanup();
+        }
+      };
+    };
+    this.subscribe = (listener) => {
+      var _a, _b;
+      this.listeners.add(listener);
+      const unsub = (_b = (_a = this.options).onSubscribe) == null ? void 0 : _b.call(_a, listener, this);
+      return () => {
+        this.listeners.delete(listener);
+        unsub == null ? void 0 : unsub();
+      };
+    };
+    this.options = options;
+    this.state = options.fn({
+      prevDepVals: void 0,
+      prevVal: void 0,
+      currDepVals: this.getDepVals().currDepVals
+    });
+  }
+  registerOnGraph(deps = this.options.deps) {
+    for (const dep of deps) {
+      if (dep instanceof Derived) {
+        dep.registerOnGraph();
+        this.registerOnGraph(dep.options.deps);
+      } else if (dep instanceof Store) {
+        let relatedLinkedDerivedVals = __storeToDerived.get(dep);
+        if (!relatedLinkedDerivedVals) {
+          relatedLinkedDerivedVals = /* @__PURE__ */ new Set();
+          __storeToDerived.set(dep, relatedLinkedDerivedVals);
+        }
+        relatedLinkedDerivedVals.add(this);
+        let relatedStores = __derivedToStore.get(this);
+        if (!relatedStores) {
+          relatedStores = /* @__PURE__ */ new Set();
+          __derivedToStore.set(this, relatedStores);
+        }
+        relatedStores.add(dep);
+      }
+    }
+  }
+  unregisterFromGraph(deps = this.options.deps) {
+    for (const dep of deps) {
+      if (dep instanceof Derived) {
+        this.unregisterFromGraph(dep.options.deps);
+      } else if (dep instanceof Store) {
+        const relatedLinkedDerivedVals = __storeToDerived.get(dep);
+        if (relatedLinkedDerivedVals) {
+          relatedLinkedDerivedVals.delete(this);
+        }
+        const relatedStores = __derivedToStore.get(this);
+        if (relatedStores) {
+          relatedStores.delete(dep);
+        }
+      }
+    }
+  }
+}
+
+function useStore(store, selector = (d) => d) {
+  const slice = withSelectorExports.useSyncExternalStoreWithSelector(
+    store.subscribe,
+    () => store.state,
+    () => store.state,
+    selector,
+    shallow
+  );
+  return slice;
+}
+function shallow(objA, objB) {
+  if (Object.is(objA, objB)) {
+    return true;
+  }
+  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+    return false;
+  }
+  if (objA instanceof Map && objB instanceof Map) {
+    if (objA.size !== objB.size) return false;
+    for (const [k, v] of objA) {
+      if (!objB.has(k) || !Object.is(v, objB.get(k))) return false;
+    }
+    return true;
+  }
+  if (objA instanceof Set && objB instanceof Set) {
+    if (objA.size !== objB.size) return false;
+    for (const v of objA) {
+      if (!objB.has(v)) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(objA);
+  if (keysA.length !== Object.keys(objB).length) {
+    return false;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+const bootStore = new Store({
+    context: 'web',
+    environments: {
+        appBaseUrl: undefined,
+        appTimeout: 30000,
+    },
+    middleware: (next) => {
+        return next();
+    },
+    modelConfig: undefined,
+});
+
+const bootstrapQueryRequest = async (queryClient, options) => {
+    // set default query config
+    await queryClient.resumePausedMutations();
+    bootStore.setState(() => options);
 };
 
 const useReactNativeEnv = () => {
-    const config = useQueryConfig();
-    const appUrl = config.options?.environments?.appBaseUrl;
-    const appTimeout = config.options?.environments?.appTimeout;
-    const isApp = config.options?.context === 'app';
+    const { environments, context } = useStore(bootStore);
+    const appUrl = environments?.appBaseUrl;
+    const appTimeout = environments?.appTimeout;
+    const isApp = context === 'app';
     return { appUrl, appTimeout, isApp };
 };
 
@@ -127,7 +803,7 @@ const useQueryModel = (keyTracker) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
-    const config = useQueryConfig();
+    const config = useStore(bootStore);
     const add = (data, position, path) => {
         let records = (findAll(path) ?? []);
         if (!position || position === 'end') {
@@ -183,8 +859,7 @@ const useQueryModel = (keyTracker) => {
         return queryClient.setQueryData(queryKey, () => newData);
     };
     const getModelConfig = () => {
-        const { options } = config;
-        const { modelConfig } = options ?? {};
+        const { modelConfig } = config;
         return modelConfig;
     };
     const update = (id, data, path) => {
@@ -422,7 +1097,7 @@ const useDeleteRequest = (deleteOptions) => {
     const { baseUrl, headers } = deleteOptions ?? {};
     const [requestPath, setRequestPath] = useState('');
     const [options, setOptions] = useState();
-    const { options: queryConfigOptions } = useQueryConfig();
+    const { middleware } = useStore(bootStore);
     const [requestPayload, setRequestPayload] = useState();
     const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
@@ -438,9 +1113,9 @@ const useDeleteRequest = (deleteOptions) => {
             timeout: TIMEOUT,
         };
         let deleteResponse;
-        if (queryConfigOptions?.middleware) {
+        if (middleware) {
             // perform global middleware
-            deleteResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
+            deleteResponse = await middleware(async (middlewareOptions) => await makeRequest(middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions), {
                 path: requestUrl,
                 baseUrl: baseUrl ?? API_URL,
             });
@@ -497,7 +1172,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     const globalHeaders = useHeaderStore((state) => state.headers);
     const [requestPath, setRequestPath] = useState(path);
     const [options, setOptions] = useState(queryOptions);
-    const { options: queryConfigOptions } = useQueryConfig();
+    const { middleware } = useStore(bootStore);
     const [requestPayload, setRequestPayload] = useState();
     const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
     let queryClient = useQueryClient();
@@ -513,9 +1188,9 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
                 timeout: TIMEOUT,
             };
             let getResponse;
-            if (queryConfigOptions?.middleware) {
+            if (middleware) {
                 // perform global middleware
-                getResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
+                getResponse = await middleware(async (middlewareOptions) => await makeRequest(middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions), {
                     path,
                     baseUrl: baseUrl ?? API_URL,
                 });
@@ -602,8 +1277,8 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const [options, setOptions] = useState(queryOptions);
     const [page, setPage] = useState(1);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { middleware } = useStore(bootStore);
     const globalHeaders = useHeaderStore((state) => state.headers);
-    const { options: queryConfigOptions } = useQueryConfig();
     const [requestPayload, setRequestPayload] = useState();
     const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
     let queryClient = useQueryClient();
@@ -619,9 +1294,9 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
             timeout: TIMEOUT,
         };
         let getResponse;
-        if (queryConfigOptions?.middleware) {
+        if (middleware) {
             // perform global middleware
-            getResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
+            getResponse = await middleware(async (middlewareOptions) => await makeRequest(middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions), {
                 path,
                 baseUrl: baseUrl ?? API_URL,
             });
@@ -734,7 +1409,7 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
     const globalHeaders = useHeaderStore((state) => state.headers);
     const [requestPayload, setRequestPayload] = useState();
     const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
-    const config = useQueryConfig();
+    const { middleware, context } = useStore(bootStore);
     const sendRequest = async (res, rej, data) => {
         // get request headers
         const requestOptions = {
@@ -747,9 +1422,9 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
             onUploadProgress,
         };
         let patchResponse;
-        if (config.options?.middleware) {
+        if (middleware) {
             // perform global middleware
-            const middlewareResponse = await config.options.middleware(async () => await makeRequest(requestOptions), {
+            const middlewareResponse = await middleware(async (options) => await makeRequest(options ? { ...requestOptions, ...options } : requestOptions), {
                 path,
                 baseUrl: baseUrl ?? API_URL,
                 body: data,
@@ -761,14 +1436,14 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         }
         if (patchResponse.status) {
             // scroll to top after success
-            if (config.options?.context !== 'app') {
+            if (context !== 'app') {
                 scrollToTop();
             }
             res(patchResponse);
         }
         else {
             // scroll to top after error
-            if (config.options?.context !== 'app') {
+            if (context !== 'app') {
                 scrollToTop();
             }
             rej(patchResponse);
@@ -802,7 +1477,7 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const config = useQueryConfig();
+    const { middleware, context } = useStore(bootStore);
     const globalHeaders = useHeaderStore((state) => state.headers);
     const { isApp } = useReactNativeEnv();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
@@ -828,9 +1503,9 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
             ...requestConfig,
         };
         let postResponse;
-        if (config.options?.middleware) {
+        if (middleware) {
             // perform global middleware
-            postResponse = await config.options.middleware(async () => await makeRequest(requestOptions), {
+            postResponse = await middleware(async (options) => await makeRequest(options ? { ...requestOptions, ...options } : requestOptions), {
                 path,
                 baseUrl: baseUrl ?? API_URL,
                 body: data,
@@ -841,14 +1516,14 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         }
         if (postResponse.status) {
             // scroll to top after success
-            if (config.options?.context !== 'app') {
+            if (context !== 'app') {
                 scrollToTop();
             }
             res(postResponse);
         }
         else {
             // scroll to top after error
-            if (config.options?.context !== 'app') {
+            if (context !== 'app') {
                 scrollToTop();
             }
             rej(postResponse);
@@ -879,5 +1554,5 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
     return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isPending || isFutureMutationsPaused };
 };
 
-export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useHeaderStore, useKeyTrackerModel, usePatchRequest, usePauseFutureRequests, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery, useUploadProgress };
+export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useHeaderStore, useKeyTrackerModel, usePatchRequest, usePauseFutureRequests, usePostRequest, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery, useUploadProgress };
 //# sourceMappingURL=index.mjs.map