@gaddario98/react-core 2.0.8 → 2.1.0

package/dist/pages/index.mjs

@@ -1,4 +1,4 @@
-import {jsx,jsxs}from'react/jsx-runtime';import React,{useReducer,useEffect,useDebugValue,useCallback,useContext,createContext,useRef,useState,memo,useMemo}from'react';import {useApiValues,useApiConfigValue,useApi,queriesAtom}from'@gaddario98/react-queries';import {c}from'react/compiler-runtime';import {atomStateGenerator}from'@gaddario98/react-state';import equal from'fast-deep-equal';import {useFormValues,useFormManager}from'@gaddario98/react-form';/******************************************************************************
+import {jsx,jsxs}from'react/jsx-runtime';import {useRef,useState,useEffect,useCallback,memo,useMemo,createContext,useContext}from'react';import {useApiValues,useApiConfigValue,useApi,queriesAtom}from'@gaddario98/react-queries';import {atom,useAtom,useStore}from'jotai';import {c}from'react/compiler-runtime';import {atomStateGenerator}from'@gaddario98/react-state';import equal from'fast-deep-equal';import {useFormValues,useFormManager}from'@gaddario98/react-form';import {atomFamily}from'jotai-family';import {QueryObserver}from'@tanstack/react-query';/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -25,839 +25,7 @@ function __rest(s, e) {
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
   var e = new Error(message);
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};function hasInitialValue(atom) {
-  return "init" in atom;
-}
-function isActuallyWritableAtom(atom) {
-  return !!atom.write;
-}
-function isAtomStateInitialized(atomState) {
-  return "v" in atomState || "e" in atomState;
-}
-function returnAtomValue(atomState) {
-  if ("e" in atomState) {
-    throw atomState.e;
-  }
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("v" in atomState)) {
-    throw new Error("[Bug] atom state is not initialized");
-  }
-  return atomState.v;
-}
-const promiseStateMap = /* @__PURE__ */ new WeakMap();
-function isPendingPromise(value) {
-  var _a;
-  return isPromiseLike$1(value) && !!((_a = promiseStateMap.get(value)) == null ? void 0 : _a[0]);
-}
-function abortPromise(promise) {
-  const promiseState = promiseStateMap.get(promise);
-  if (promiseState == null ? void 0 : promiseState[0]) {
-    promiseState[0] = false;
-    promiseState[1].forEach((fn) => fn());
-  }
-}
-function registerAbortHandler(promise, abortHandler) {
-  let promiseState = promiseStateMap.get(promise);
-  if (!promiseState) {
-    promiseState = [true, /* @__PURE__ */ new Set()];
-    promiseStateMap.set(promise, promiseState);
-    const settle = () => {
-      promiseState[0] = false;
-    };
-    promise.then(settle, settle);
-  }
-  promiseState[1].add(abortHandler);
-}
-function isPromiseLike$1(p) {
-  return typeof (p == null ? void 0 : p.then) === "function";
-}
-function addPendingPromiseToDependency(atom, promise, dependencyAtomState) {
-  if (!dependencyAtomState.p.has(atom)) {
-    dependencyAtomState.p.add(atom);
-    const cleanup = () => dependencyAtomState.p.delete(atom);
-    promise.then(cleanup, cleanup);
-  }
-}
-function getMountedOrPendingDependents(atom, atomState, mountedMap) {
-  var _a;
-  const dependents = /* @__PURE__ */ new Set();
-  for (const a of ((_a = mountedMap.get(atom)) == null ? void 0 : _a.t) || []) {
-    dependents.add(a);
-  }
-  for (const atomWithPendingPromise of atomState.p) {
-    dependents.add(atomWithPendingPromise);
-  }
-  return dependents;
-}
-const BUILDING_BLOCK_atomRead = (_store, atom, ...params) => atom.read(...params);
-const BUILDING_BLOCK_atomWrite = (_store, atom, ...params) => atom.write(...params);
-const BUILDING_BLOCK_atomOnInit = (store, atom) => {
-  var _a;
-  return (_a = atom.INTERNAL_onInit) == null ? void 0 : _a.call(atom, store);
-};
-const BUILDING_BLOCK_atomOnMount = (_store, atom, setAtom) => {
-  var _a;
-  return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
-};
-const BUILDING_BLOCK_ensureAtomState = (store, atom) => {
-  var _a;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const atomStateMap = buildingBlocks[0];
-  const storeHooks = buildingBlocks[6];
-  const atomOnInit = buildingBlocks[9];
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !atom) {
-    throw new Error("Atom is undefined or null");
-  }
-  let atomState = atomStateMap.get(atom);
-  if (!atomState) {
-    atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };
-    atomStateMap.set(atom, atomState);
-    (_a = storeHooks.i) == null ? void 0 : _a.call(storeHooks, atom);
-    atomOnInit == null ? void 0 : atomOnInit(store, atom);
-  }
-  return atomState;
-};
-const BUILDING_BLOCK_flushCallbacks = (store) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const changedAtoms = buildingBlocks[3];
-  const mountCallbacks = buildingBlocks[4];
-  const unmountCallbacks = buildingBlocks[5];
-  const storeHooks = buildingBlocks[6];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const errors = [];
-  const call = (fn) => {
-    try {
-      fn();
-    } catch (e) {
-      errors.push(e);
-    }
-  };
-  do {
-    if (storeHooks.f) {
-      call(storeHooks.f);
-    }
-    const callbacks = /* @__PURE__ */ new Set();
-    const add = callbacks.add.bind(callbacks);
-    changedAtoms.forEach((atom) => {
-      var _a;
-      return (_a = mountedMap.get(atom)) == null ? void 0 : _a.l.forEach(add);
-    });
-    changedAtoms.clear();
-    unmountCallbacks.forEach(add);
-    unmountCallbacks.clear();
-    mountCallbacks.forEach(add);
-    mountCallbacks.clear();
-    callbacks.forEach(call);
-    if (changedAtoms.size) {
-      recomputeInvalidatedAtoms(store);
-    }
-  } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
-  if (errors.length) {
-    throw new AggregateError(errors);
-  }
-};
-const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const invalidatedAtoms = buildingBlocks[2];
-  const changedAtoms = buildingBlocks[3];
-  const ensureAtomState = buildingBlocks[11];
-  const readAtomState = buildingBlocks[14];
-  const mountDependencies = buildingBlocks[17];
-  const topSortedReversed = [];
-  const visiting = /* @__PURE__ */ new WeakSet();
-  const visited = /* @__PURE__ */ new WeakSet();
-  const stack = Array.from(changedAtoms);
-  while (stack.length) {
-    const a = stack[stack.length - 1];
-    const aState = ensureAtomState(store, a);
-    if (visited.has(a)) {
-      stack.pop();
-      continue;
-    }
-    if (visiting.has(a)) {
-      if (invalidatedAtoms.get(a) === aState.n) {
-        topSortedReversed.push([a, aState]);
-      } else if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && invalidatedAtoms.has(a)) {
-        throw new Error("[Bug] invalidated atom exists");
-      }
-      visited.add(a);
-      stack.pop();
-      continue;
-    }
-    visiting.add(a);
-    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      if (!visiting.has(d)) {
-        stack.push(d);
-      }
-    }
-  }
-  for (let i = topSortedReversed.length - 1; i >= 0; --i) {
-    const [a, aState] = topSortedReversed[i];
-    let hasChangedDeps = false;
-    for (const dep of aState.d.keys()) {
-      if (dep !== a && changedAtoms.has(dep)) {
-        hasChangedDeps = true;
-        break;
-      }
-    }
-    if (hasChangedDeps) {
-      readAtomState(store, a);
-      mountDependencies(store, a);
-    }
-    invalidatedAtoms.delete(a);
-  }
-};
-const storeMutationSet = /* @__PURE__ */ new WeakSet();
-const BUILDING_BLOCK_readAtomState = (store, atom) => {
-  var _a, _b;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const invalidatedAtoms = buildingBlocks[2];
-  const changedAtoms = buildingBlocks[3];
-  const storeHooks = buildingBlocks[6];
-  const atomRead = buildingBlocks[7];
-  const ensureAtomState = buildingBlocks[11];
-  const flushCallbacks = buildingBlocks[12];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const readAtomState = buildingBlocks[14];
-  const writeAtomState = buildingBlocks[16];
-  const mountDependencies = buildingBlocks[17];
-  const setAtomStateValueOrPromise = buildingBlocks[20];
-  const atomState = ensureAtomState(store, atom);
-  if (isAtomStateInitialized(atomState)) {
-    if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
-      return atomState;
-    }
-    let hasChangedDeps = false;
-    for (const [a, n] of atomState.d) {
-      if (readAtomState(store, a).n !== n) {
-        hasChangedDeps = true;
-        break;
-      }
-    }
-    if (!hasChangedDeps) {
-      return atomState;
-    }
-  }
-  atomState.d.clear();
-  let isSync = true;
-  function mountDependenciesIfAsync() {
-    if (mountedMap.has(atom)) {
-      mountDependencies(store, atom);
-      recomputeInvalidatedAtoms(store);
-      flushCallbacks(store);
-    }
-  }
-  function getter(a) {
-    var _a2;
-    if (a === atom) {
-      const aState2 = ensureAtomState(store, a);
-      if (!isAtomStateInitialized(aState2)) {
-        if (hasInitialValue(a)) {
-          setAtomStateValueOrPromise(store, a, a.init);
-        } else {
-          throw new Error("no atom init");
-        }
-      }
-      return returnAtomValue(aState2);
-    }
-    const aState = readAtomState(store, a);
-    try {
-      return returnAtomValue(aState);
-    } finally {
-      atomState.d.set(a, aState.n);
-      if (isPendingPromise(atomState.v)) {
-        addPendingPromiseToDependency(atom, atomState.v, aState);
-      }
-      if (mountedMap.has(atom)) {
-        (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.t.add(atom);
-      }
-      if (!isSync) {
-        mountDependenciesIfAsync();
-      }
-    }
-  }
-  let controller;
-  let setSelf;
-  const options = {
-    get signal() {
-      if (!controller) {
-        controller = new AbortController();
-      }
-      return controller.signal;
-    },
-    get setSelf() {
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-        console.warn(
-          "[DEPRECATED] setSelf is deprecated and will be removed in v3."
-        );
-      }
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) {
-        console.warn("setSelf function cannot be used with read-only atom");
-      }
-      if (!setSelf && isActuallyWritableAtom(atom)) {
-        setSelf = (...args) => {
-          if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && isSync) {
-            console.warn("setSelf function cannot be called in sync");
-          }
-          if (!isSync) {
-            try {
-              return writeAtomState(store, atom, ...args);
-            } finally {
-              recomputeInvalidatedAtoms(store);
-              flushCallbacks(store);
-            }
-          }
-        };
-      }
-      return setSelf;
-    }
-  };
-  const prevEpochNumber = atomState.n;
-  try {
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-      storeMutationSet.delete(store);
-    }
-    const valueOrPromise = atomRead(store, atom, getter, options);
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && storeMutationSet.has(store)) {
-      console.warn(
-        "Detected store mutation during atom read. This is not supported."
-      );
-    }
-    setAtomStateValueOrPromise(store, atom, valueOrPromise);
-    if (isPromiseLike$1(valueOrPromise)) {
-      registerAbortHandler(valueOrPromise, () => controller == null ? void 0 : controller.abort());
-      valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
-    }
-    (_a = storeHooks.r) == null ? void 0 : _a.call(storeHooks, atom);
-    return atomState;
-  } catch (error) {
-    delete atomState.v;
-    atomState.e = error;
-    ++atomState.n;
-    return atomState;
-  } finally {
-    isSync = false;
-    if (prevEpochNumber !== atomState.n && invalidatedAtoms.get(atom) === prevEpochNumber) {
-      invalidatedAtoms.set(atom, atomState.n);
-      changedAtoms.add(atom);
-      (_b = storeHooks.c) == null ? void 0 : _b.call(storeHooks, atom);
-    }
-  }
-};
-const BUILDING_BLOCK_invalidateDependents = (store, atom) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const invalidatedAtoms = buildingBlocks[2];
-  const ensureAtomState = buildingBlocks[11];
-  const stack = [atom];
-  while (stack.length) {
-    const a = stack.pop();
-    const aState = ensureAtomState(store, a);
-    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      const dState = ensureAtomState(store, d);
-      invalidatedAtoms.set(d, dState.n);
-      stack.push(d);
-    }
-  }
-};
-const BUILDING_BLOCK_writeAtomState = (store, atom, ...args) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const changedAtoms = buildingBlocks[3];
-  const storeHooks = buildingBlocks[6];
-  const atomWrite = buildingBlocks[8];
-  const ensureAtomState = buildingBlocks[11];
-  const flushCallbacks = buildingBlocks[12];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const readAtomState = buildingBlocks[14];
-  const invalidateDependents = buildingBlocks[15];
-  const writeAtomState = buildingBlocks[16];
-  const mountDependencies = buildingBlocks[17];
-  const setAtomStateValueOrPromise = buildingBlocks[20];
-  let isSync = true;
-  const getter = (a) => returnAtomValue(readAtomState(store, a));
-  const setter = (a, ...args2) => {
-    var _a;
-    const aState = ensureAtomState(store, a);
-    try {
-      if (a === atom) {
-        if (!hasInitialValue(a)) {
-          throw new Error("atom not writable");
-        }
-        if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-          storeMutationSet.add(store);
-        }
-        const prevEpochNumber = aState.n;
-        const v = args2[0];
-        setAtomStateValueOrPromise(store, a, v);
-        mountDependencies(store, a);
-        if (prevEpochNumber !== aState.n) {
-          changedAtoms.add(a);
-          invalidateDependents(store, a);
-          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
-        }
-        return void 0;
-      } else {
-        return writeAtomState(store, a, ...args2);
-      }
-    } finally {
-      if (!isSync) {
-        recomputeInvalidatedAtoms(store);
-        flushCallbacks(store);
-      }
-    }
-  };
-  try {
-    return atomWrite(store, atom, getter, setter, ...args);
-  } finally {
-    isSync = false;
-  }
-};
-const BUILDING_BLOCK_mountDependencies = (store, atom) => {
-  var _a;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const changedAtoms = buildingBlocks[3];
-  const storeHooks = buildingBlocks[6];
-  const ensureAtomState = buildingBlocks[11];
-  const invalidateDependents = buildingBlocks[15];
-  const mountAtom = buildingBlocks[18];
-  const unmountAtom = buildingBlocks[19];
-  const atomState = ensureAtomState(store, atom);
-  const mounted = mountedMap.get(atom);
-  if (mounted && !isPendingPromise(atomState.v)) {
-    for (const [a, n] of atomState.d) {
-      if (!mounted.d.has(a)) {
-        const aState = ensureAtomState(store, a);
-        const aMounted = mountAtom(store, a);
-        aMounted.t.add(atom);
-        mounted.d.add(a);
-        if (n !== aState.n) {
-          changedAtoms.add(a);
-          invalidateDependents(store, a);
-          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
-        }
-      }
-    }
-    for (const a of mounted.d) {
-      if (!atomState.d.has(a)) {
-        mounted.d.delete(a);
-        const aMounted = unmountAtom(store, a);
-        aMounted == null ? void 0 : aMounted.t.delete(atom);
-      }
-    }
-  }
-};
-const BUILDING_BLOCK_mountAtom = (store, atom) => {
-  var _a;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const mountCallbacks = buildingBlocks[4];
-  const storeHooks = buildingBlocks[6];
-  const atomOnMount = buildingBlocks[10];
-  const ensureAtomState = buildingBlocks[11];
-  const flushCallbacks = buildingBlocks[12];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const readAtomState = buildingBlocks[14];
-  const writeAtomState = buildingBlocks[16];
-  const mountAtom = buildingBlocks[18];
-  const atomState = ensureAtomState(store, atom);
-  let mounted = mountedMap.get(atom);
-  if (!mounted) {
-    readAtomState(store, atom);
-    for (const a of atomState.d.keys()) {
-      const aMounted = mountAtom(store, a);
-      aMounted.t.add(atom);
-    }
-    mounted = {
-      l: /* @__PURE__ */ new Set(),
-      d: new Set(atomState.d.keys()),
-      t: /* @__PURE__ */ new Set()
-    };
-    mountedMap.set(atom, mounted);
-    if (isActuallyWritableAtom(atom)) {
-      const processOnMount = () => {
-        let isSync = true;
-        const setAtom = (...args) => {
-          try {
-            return writeAtomState(store, atom, ...args);
-          } finally {
-            if (!isSync) {
-              recomputeInvalidatedAtoms(store);
-              flushCallbacks(store);
-            }
-          }
-        };
-        try {
-          const onUnmount = atomOnMount(store, atom, setAtom);
-          if (onUnmount) {
-            mounted.u = () => {
-              isSync = true;
-              try {
-                onUnmount();
-              } finally {
-                isSync = false;
-              }
-            };
-          }
-        } finally {
-          isSync = false;
-        }
-      };
-      mountCallbacks.add(processOnMount);
-    }
-    (_a = storeHooks.m) == null ? void 0 : _a.call(storeHooks, atom);
-  }
-  return mounted;
-};
-const BUILDING_BLOCK_unmountAtom = (store, atom) => {
-  var _a, _b;
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const unmountCallbacks = buildingBlocks[5];
-  const storeHooks = buildingBlocks[6];
-  const ensureAtomState = buildingBlocks[11];
-  const unmountAtom = buildingBlocks[19];
-  const atomState = ensureAtomState(store, atom);
-  let mounted = mountedMap.get(atom);
-  if (!mounted || mounted.l.size) {
-    return mounted;
-  }
-  let isDependent = false;
-  for (const a of mounted.t) {
-    if ((_a = mountedMap.get(a)) == null ? void 0 : _a.d.has(atom)) {
-      isDependent = true;
-      break;
-    }
-  }
-  if (!isDependent) {
-    if (mounted.u) {
-      unmountCallbacks.add(mounted.u);
-    }
-    mounted = void 0;
-    mountedMap.delete(atom);
-    for (const a of atomState.d.keys()) {
-      const aMounted = unmountAtom(store, a);
-      aMounted == null ? void 0 : aMounted.t.delete(atom);
-    }
-    (_b = storeHooks.u) == null ? void 0 : _b.call(storeHooks, atom);
-    return void 0;
-  }
-  return mounted;
-};
-const BUILDING_BLOCK_setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
-  const ensureAtomState = getInternalBuildingBlocks(store)[11];
-  const atomState = ensureAtomState(store, atom);
-  const hasPrevValue = "v" in atomState;
-  const prevValue = atomState.v;
-  if (isPromiseLike$1(valueOrPromise)) {
-    for (const a of atomState.d.keys()) {
-      addPendingPromiseToDependency(
-        atom,
-        valueOrPromise,
-        ensureAtomState(store, a)
-      );
-    }
-  }
-  atomState.v = valueOrPromise;
-  delete atomState.e;
-  if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
-    ++atomState.n;
-    if (isPromiseLike$1(prevValue)) {
-      abortPromise(prevValue);
-    }
-  }
-};
-const BUILDING_BLOCK_storeGet = (store, atom) => {
-  const readAtomState = getInternalBuildingBlocks(store)[14];
-  return returnAtomValue(readAtomState(store, atom));
-};
-const BUILDING_BLOCK_storeSet = (store, atom, ...args) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks = buildingBlocks[12];
-  const recomputeInvalidatedAtoms = buildingBlocks[13];
-  const writeAtomState = buildingBlocks[16];
-  try {
-    return writeAtomState(store, atom, ...args);
-  } finally {
-    recomputeInvalidatedAtoms(store);
-    flushCallbacks(store);
-  }
-};
-const BUILDING_BLOCK_storeSub = (store, atom, listener) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks = buildingBlocks[12];
-  const mountAtom = buildingBlocks[18];
-  const unmountAtom = buildingBlocks[19];
-  const mounted = mountAtom(store, atom);
-  const listeners = mounted.l;
-  listeners.add(listener);
-  flushCallbacks(store);
-  return () => {
-    listeners.delete(listener);
-    unmountAtom(store, atom);
-    flushCallbacks(store);
-  };
-};
-const buildingBlockMap = /* @__PURE__ */ new WeakMap();
-const getInternalBuildingBlocks = (store) => {
-  const buildingBlocks = buildingBlockMap.get(store);
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !buildingBlocks) {
-    throw new Error(
-      "Store must be created by buildStore to read its building blocks"
-    );
-  }
-  return buildingBlocks;
-};
-function buildStore(...buildArgs) {
-  const store = {
-    get(atom) {
-      const storeGet = getInternalBuildingBlocks(store)[21];
-      return storeGet(store, atom);
-    },
-    set(atom, ...args) {
-      const storeSet = getInternalBuildingBlocks(store)[22];
-      return storeSet(store, atom, ...args);
-    },
-    sub(atom, listener) {
-      const storeSub = getInternalBuildingBlocks(store)[23];
-      return storeSub(store, atom, listener);
-    }
-  };
-  const buildingBlocks = [
-    // store state
-    /* @__PURE__ */ new WeakMap(),
-    // atomStateMap
-    /* @__PURE__ */ new WeakMap(),
-    // mountedMap
-    /* @__PURE__ */ new WeakMap(),
-    // invalidatedAtoms
-    /* @__PURE__ */ new Set(),
-    // changedAtoms
-    /* @__PURE__ */ new Set(),
-    // mountCallbacks
-    /* @__PURE__ */ new Set(),
-    // unmountCallbacks
-    {},
-    // storeHooks
-    // atom interceptors
-    BUILDING_BLOCK_atomRead,
-    BUILDING_BLOCK_atomWrite,
-    BUILDING_BLOCK_atomOnInit,
-    BUILDING_BLOCK_atomOnMount,
-    // building-block functions
-    BUILDING_BLOCK_ensureAtomState,
-    BUILDING_BLOCK_flushCallbacks,
-    BUILDING_BLOCK_recomputeInvalidatedAtoms,
-    BUILDING_BLOCK_readAtomState,
-    BUILDING_BLOCK_invalidateDependents,
-    BUILDING_BLOCK_writeAtomState,
-    BUILDING_BLOCK_mountDependencies,
-    BUILDING_BLOCK_mountAtom,
-    BUILDING_BLOCK_unmountAtom,
-    BUILDING_BLOCK_setAtomStateValueOrPromise,
-    BUILDING_BLOCK_storeGet,
-    BUILDING_BLOCK_storeSet,
-    BUILDING_BLOCK_storeSub,
-    void 0
-  ].map((fn, i) => buildArgs[i] || fn);
-  buildingBlockMap.set(store, Object.freeze(buildingBlocks));
-  return store;
-}let keyCount = 0;
-function atom(read, write) {
-  const key = `atom${++keyCount}`;
-  const config = {
-    toString() {
-      return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
-    }
-  };
-  if (typeof read === "function") {
-    config.read = read;
-  } else {
-    config.init = read;
-    config.read = defaultRead;
-    config.write = defaultWrite;
-  }
-  if (write) {
-    config.write = write;
-  }
-  return config;
-}
-function defaultRead(get) {
-  return get(this);
-}
-function defaultWrite(get, set, arg) {
-  return set(
-    this,
-    typeof arg === "function" ? arg(get(this)) : arg
-  );
-}
-function createStore() {
-  return buildStore();
-}
-let defaultStore;
-function getDefaultStore() {
-  if (!defaultStore) {
-    defaultStore = createStore();
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-      globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);
-      if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {
-        console.warn(
-          "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
-        );
-      }
-    }
-  }
-  return defaultStore;
-}const StoreContext = createContext(
-  void 0
-);
-function useStore(options) {
-  const store = useContext(StoreContext);
-  return store || getDefaultStore();
-}
-
-const isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
-const attachPromiseStatus = (promise) => {
-  if (!promise.status) {
-    promise.status = "pending";
-    promise.then(
-      (v) => {
-        promise.status = "fulfilled";
-        promise.value = v;
-      },
-      (e) => {
-        promise.status = "rejected";
-        promise.reason = e;
-      }
-    );
-  }
-};
-const use = React.use || // A shim for older React versions
-((promise) => {
-  if (promise.status === "pending") {
-    throw promise;
-  } else if (promise.status === "fulfilled") {
-    return promise.value;
-  } else if (promise.status === "rejected") {
-    throw promise.reason;
-  } else {
-    attachPromiseStatus(promise);
-    throw promise;
-  }
-});
-const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
-const createContinuablePromise = (promise, getValue) => {
-  let continuablePromise = continuablePromiseMap.get(promise);
-  if (!continuablePromise) {
-    continuablePromise = new Promise((resolve, reject) => {
-      let curr = promise;
-      const onFulfilled = (me) => (v) => {
-        if (curr === me) {
-          resolve(v);
-        }
-      };
-      const onRejected = (me) => (e) => {
-        if (curr === me) {
-          reject(e);
-        }
-      };
-      const onAbort = () => {
-        try {
-          const nextValue = getValue();
-          if (isPromiseLike(nextValue)) {
-            continuablePromiseMap.set(nextValue, continuablePromise);
-            curr = nextValue;
-            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
-            registerAbortHandler(nextValue, onAbort);
-          } else {
-            resolve(nextValue);
-          }
-        } catch (e) {
-          reject(e);
-        }
-      };
-      promise.then(onFulfilled(promise), onRejected(promise));
-      registerAbortHandler(promise, onAbort);
-    });
-    continuablePromiseMap.set(promise, continuablePromise);
-  }
-  return continuablePromise;
-};
-function useAtomValue(atom, options) {
-  const { delay, unstable_promiseStatus: promiseStatus = !React.use } = {};
-  const store = useStore();
-  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer(
-    (prev) => {
-      const nextValue = store.get(atom);
-      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
-        return prev;
-      }
-      return [nextValue, store, atom];
-    },
-    void 0,
-    () => [store.get(atom), store, atom]
-  );
-  let value = valueFromReducer;
-  if (storeFromReducer !== store || atomFromReducer !== atom) {
-    rerender();
-    value = store.get(atom);
-  }
-  useEffect(() => {
-    const unsub = store.sub(atom, () => {
-      if (promiseStatus) {
-        try {
-          const value2 = store.get(atom);
-          if (isPromiseLike(value2)) {
-            attachPromiseStatus(
-              createContinuablePromise(value2, () => store.get(atom))
-            );
-          }
-        } catch (e) {
-        }
-      }
-      if (typeof delay === "number") {
-        setTimeout(rerender, delay);
-        return;
-      }
-      rerender();
-    });
-    rerender();
-    return unsub;
-  }, [store, atom, delay, promiseStatus]);
-  useDebugValue(value);
-  if (isPromiseLike(value)) {
-    const promise = createContinuablePromise(value, () => store.get(atom));
-    if (promiseStatus) {
-      attachPromiseStatus(promise);
-    }
-    return use(promise);
-  }
-  return value;
-}
-
-function useSetAtom(atom, options) {
-  const store = useStore();
-  const setAtom = useCallback(
-    (...args) => {
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("write" in atom)) {
-        throw new Error("not writable atom");
-      }
-      return store.set(atom, ...args);
-    },
-    [store, atom]
-  );
-  return setAtom;
-}
-
-function useAtom(atom, options) {
-  return [
-    useAtomValue(atom),
-    // We do wrong type assertion here, which results in throwing an error.
-    useSetAtom(atom)
-  ];
-}/* eslint-disable @typescript-eslint/no-explicit-any */
+};/* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * Optimized shallow equality check for objects and functions
  * @param objA - First object to compare
@@ -982,61 +150,6 @@ function memoize(fn, cacheKeyFn) {
     cache.set(cacheKey, result);
     return result;
   };
-}function atomFamily(initializeAtom, areEqual) {
-    let shouldRemove = null;
-    const atoms = new Map();
-    const listeners = new Set();
-    function createAtom(param) {
-        let item;
-        {
-            item = atoms.get(param);
-        }
-        if (item !== undefined) {
-            if (shouldRemove?.(item[1], param)) {
-                createAtom.remove(param);
-            }
-            else {
-                return item[0];
-            }
-        }
-        const newAtom = initializeAtom(param);
-        atoms.set(param, [newAtom, Date.now()]);
-        notifyListeners('CREATE', param, newAtom);
-        return newAtom;
-    }
-    function notifyListeners(type, param, atom) {
-        for (const listener of listeners) {
-            listener({ type, param, atom });
-        }
-    }
-    createAtom.unstable_listen = (callback) => {
-        listeners.add(callback);
-        return () => {
-            listeners.delete(callback);
-        };
-    };
-    createAtom.getParams = () => atoms.keys();
-    createAtom.remove = (param) => {
-        {
-            if (!atoms.has(param))
-                return;
-            const [atom] = atoms.get(param);
-            atoms.delete(param);
-            notifyListeners('REMOVE', param, atom);
-        }
-    };
-    createAtom.setShouldRemove = (fn) => {
-        shouldRemove = fn;
-        if (!shouldRemove)
-            return;
-        for (const [key, [atom, createdAt]] of atoms) {
-            if (shouldRemove(createdAt, key)) {
-                atoms.delete(key);
-                notifyListeners('REMOVE', key, atom);
-            }
-        }
-    };
-    return createAtom;
 }const pageVariablesAtomFamily = atomFamily(_pageId => atom({}));
 /**
  * Global atom storing all page variables.
@@ -2187,9 +1300,9 @@ let _pageConfig = {
   HeaderContainer: DefaultContainer,
   FooterContainer: DefaultContainer,
   BodyContainer: DefaultContainer,
-  authPageImage: '',
+  authPageImage: "",
   authPageProps: {
-    id: 'auth-page'
+    id: "auth-page"
   },
   isLogged: val => !!(val === null || val === void 0 ? void 0 : val.id) && !!val.isLogged,
   ItemsContainer: ({
@@ -2199,8 +1312,8 @@ let _pageConfig = {
     children
   }) => children,
   meta: {
-    title: '',
-    description: ''
+    title: "",
+    description: ""
   },
   // Metadata configuration
   defaultMetadata: {},
@@ -2213,7 +1326,7 @@ let _pageConfig = {
     preloadOnHover: false,
     preloadOnFocus: false,
     timeout: 30000,
-    logMetrics: process.env.NODE_ENV === 'development'
+    logMetrics: process.env.NODE_ENV === "development"
   }
 };
 /**
@@ -2225,9 +1338,9 @@ function initializePageConfig() {
     HeaderContainer: DefaultContainer,
     FooterContainer: DefaultContainer,
     BodyContainer: DefaultContainer,
-    authPageImage: '',
+    authPageImage: "",
     authPageProps: {
-      id: 'auth-page'
+      id: "auth-page"
     },
     isLogged: val => !!(val === null || val === void 0 ? void 0 : val.id) && !!val.isLogged,
     ItemsContainer: ({
@@ -2237,8 +1350,8 @@ function initializePageConfig() {
       children
     }) => children,
     meta: {
-      title: '',
-      description: ''
+      title: "",
+      description: ""
     },
     // Metadata configuration
     defaultMetadata: {},
@@ -2251,7 +1364,7 @@ function initializePageConfig() {
       preloadOnHover: false,
       preloadOnFocus: false,
       timeout: 30000,
-      logMetrics: process.env.NODE_ENV === 'development'
+      logMetrics: process.env.NODE_ENV === "development"
     }
   };
   return _pageConfig;
@@ -2266,7 +1379,7 @@ const {
   useState: usePageConfigState,
   useReset: usePageConfigReset
 } = atomStateGenerator({
-  key: 'pageConfig',
+  key: "pageConfig",
   defaultValue: _pageConfig,
   persist: false
 });/**
@@ -2377,850 +1490,6 @@ function useFormData({
     mappedFormData,
     formSubmit
   };
-}// src/subscribable.ts
-var Subscribable = class {
-  constructor() {
-    this.listeners = /* @__PURE__ */new Set();
-    this.subscribe = this.subscribe.bind(this);
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    this.onSubscribe();
-    return () => {
-      this.listeners.delete(listener);
-      this.onUnsubscribe();
-    };
-  }
-  hasListeners() {
-    return this.listeners.size > 0;
-  }
-  onSubscribe() {}
-  onUnsubscribe() {}
-};// src/timeoutManager.ts
-var defaultTimeoutProvider = {
-  // 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: (callback, delay) => setTimeout(callback, delay),
-  clearTimeout: timeoutId => clearTimeout(timeoutId),
-  setInterval: (callback, delay) => setInterval(callback, delay),
-  clearInterval: intervalId => clearInterval(intervalId)
-};
-var TimeoutManager = class {
-  // 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.
-  #provider = defaultTimeoutProvider;
-  #providerCalled = false;
-  setTimeoutProvider(provider) {
-    if (process.env.NODE_ENV !== "production") {
-      if (this.#providerCalled && provider !== this.#provider) {
-        console.error(`[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`, {
-          previous: this.#provider,
-          provider
-        });
-      }
-    }
-    this.#provider = provider;
-    if (process.env.NODE_ENV !== "production") {
-      this.#providerCalled = false;
-    }
-  }
-  setTimeout(callback, delay) {
-    if (process.env.NODE_ENV !== "production") {
-      this.#providerCalled = true;
-    }
-    return this.#provider.setTimeout(callback, delay);
-  }
-  clearTimeout(timeoutId) {
-    this.#provider.clearTimeout(timeoutId);
-  }
-  setInterval(callback, delay) {
-    if (process.env.NODE_ENV !== "production") {
-      this.#providerCalled = true;
-    }
-    return this.#provider.setInterval(callback, delay);
-  }
-  clearInterval(intervalId) {
-    this.#provider.clearInterval(intervalId);
-  }
-};
-var timeoutManager = new TimeoutManager();
-function systemSetTimeoutZero(callback) {
-  setTimeout(callback, 0);
-}// src/utils.ts
-var isServer = typeof window === "undefined" || "Deno" in globalThis;
-function noop() {}
-function isValidTimeout(value) {
-  return typeof value === "number" && value >= 0 && value !== Infinity;
-}
-function timeUntilStale(updatedAt, staleTime) {
-  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
-}
-function resolveStaleTime(staleTime, query) {
-  return typeof staleTime === "function" ? staleTime(query) : staleTime;
-}
-function resolveEnabled(enabled, query) {
-  return typeof enabled === "function" ? enabled(query) : enabled;
-}
-var hasOwn = Object.prototype.hasOwnProperty;
-function replaceEqualDeep(a, b, depth = 0) {
-  if (a === b) {
-    return a;
-  }
-  if (depth > 500) return b;
-  const array = isPlainArray(a) && isPlainArray(b);
-  if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
-  const aItems = array ? a : Object.keys(a);
-  const aSize = aItems.length;
-  const bItems = array ? b : Object.keys(b);
-  const bSize = bItems.length;
-  const copy = array ? new Array(bSize) : {};
-  let equalItems = 0;
-  for (let i = 0; i < bSize; i++) {
-    const key = array ? i : bItems[i];
-    const aItem = a[key];
-    const bItem = b[key];
-    if (aItem === bItem) {
-      copy[key] = aItem;
-      if (array ? i < aSize : hasOwn.call(a, key)) equalItems++;
-      continue;
-    }
-    if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
-      copy[key] = bItem;
-      continue;
-    }
-    const v = replaceEqualDeep(aItem, bItem, depth + 1);
-    copy[key] = v;
-    if (v === aItem) equalItems++;
-  }
-  return aSize === bSize && equalItems === aSize ? a : copy;
-}
-function shallowEqualObjects(a, b) {
-  if (!b || Object.keys(a).length !== Object.keys(b).length) {
-    return false;
-  }
-  for (const key in a) {
-    if (a[key] !== b[key]) {
-      return false;
-    }
-  }
-  return true;
-}
-function isPlainArray(value) {
-  return Array.isArray(value) && value.length === Object.keys(value).length;
-}
-function isPlainObject(o) {
-  if (!hasObjectPrototype(o)) {
-    return false;
-  }
-  const ctor = o.constructor;
-  if (ctor === void 0) {
-    return true;
-  }
-  const prot = ctor.prototype;
-  if (!hasObjectPrototype(prot)) {
-    return false;
-  }
-  if (!prot.hasOwnProperty("isPrototypeOf")) {
-    return false;
-  }
-  if (Object.getPrototypeOf(o) !== Object.prototype) {
-    return false;
-  }
-  return true;
-}
-function hasObjectPrototype(o) {
-  return Object.prototype.toString.call(o) === "[object Object]";
-}
-function replaceData(prevData, data, options) {
-  if (typeof options.structuralSharing === "function") {
-    return options.structuralSharing(prevData, data);
-  } else if (options.structuralSharing !== false) {
-    if (process.env.NODE_ENV !== "production") {
-      try {
-        return replaceEqualDeep(prevData, data);
-      } catch (error) {
-        console.error(`Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`);
-        throw error;
-      }
-    }
-    return replaceEqualDeep(prevData, data);
-  }
-  return data;
-}// src/focusManager.ts
-var FocusManager = class extends Subscribable {
-  #focused;
-  #cleanup;
-  #setup;
-  constructor() {
-    super();
-    this.#setup = onFocus => {
-      if (!isServer && window.addEventListener) {
-        const listener = () => onFocus();
-        window.addEventListener("visibilitychange", listener, false);
-        return () => {
-          window.removeEventListener("visibilitychange", listener);
-        };
-      }
-      return;
-    };
-  }
-  onSubscribe() {
-    if (!this.#cleanup) {
-      this.setEventListener(this.#setup);
-    }
-  }
-  onUnsubscribe() {
-    if (!this.hasListeners()) {
-      this.#cleanup?.();
-      this.#cleanup = void 0;
-    }
-  }
-  setEventListener(setup) {
-    this.#setup = setup;
-    this.#cleanup?.();
-    this.#cleanup = setup(focused => {
-      if (typeof focused === "boolean") {
-        this.setFocused(focused);
-      } else {
-        this.onFocus();
-      }
-    });
-  }
-  setFocused(focused) {
-    const changed = this.#focused !== focused;
-    if (changed) {
-      this.#focused = focused;
-      this.onFocus();
-    }
-  }
-  onFocus() {
-    const isFocused = this.isFocused();
-    this.listeners.forEach(listener => {
-      listener(isFocused);
-    });
-  }
-  isFocused() {
-    if (typeof this.#focused === "boolean") {
-      return this.#focused;
-    }
-    return globalThis.document?.visibilityState !== "hidden";
-  }
-};
-var focusManager = new FocusManager();// src/thenable.ts
-function pendingThenable() {
-  let resolve;
-  let reject;
-  const thenable = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  thenable.status = "pending";
-  thenable.catch(() => {});
-  function finalize(data) {
-    Object.assign(thenable, data);
-    delete thenable.resolve;
-    delete thenable.reject;
-  }
-  thenable.resolve = value => {
-    finalize({
-      status: "fulfilled",
-      value
-    });
-    resolve(value);
-  };
-  thenable.reject = reason => {
-    finalize({
-      status: "rejected",
-      reason
-    });
-    reject(reason);
-  };
-  return thenable;
-}// src/notifyManager.ts
-var defaultScheduler = systemSetTimeoutZero;
-function createNotifyManager() {
-  let queue = [];
-  let transactions = 0;
-  let notifyFn = callback => {
-    callback();
-  };
-  let batchNotifyFn = callback => {
-    callback();
-  };
-  let scheduleFn = defaultScheduler;
-  const schedule = callback => {
-    if (transactions) {
-      queue.push(callback);
-    } else {
-      scheduleFn(() => {
-        notifyFn(callback);
-      });
-    }
-  };
-  const flush = () => {
-    const originalQueue = queue;
-    queue = [];
-    if (originalQueue.length) {
-      scheduleFn(() => {
-        batchNotifyFn(() => {
-          originalQueue.forEach(callback => {
-            notifyFn(callback);
-          });
-        });
-      });
-    }
-  };
-  return {
-    batch: callback => {
-      let result;
-      transactions++;
-      try {
-        result = callback();
-      } finally {
-        transactions--;
-        if (!transactions) {
-          flush();
-        }
-      }
-      return result;
-    },
-    /**
-     * All calls to the wrapped function will be batched.
-     */
-    batchCalls: callback => {
-      return (...args) => {
-        schedule(() => {
-          callback(...args);
-        });
-      };
-    },
-    schedule,
-    /**
-     * 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: fn => {
-      notifyFn = fn;
-    },
-    /**
-     * 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: fn => {
-      batchNotifyFn = fn;
-    },
-    setScheduler: fn => {
-      scheduleFn = fn;
-    }
-  };
-}
-var notifyManager = createNotifyManager();// src/onlineManager.ts
-var OnlineManager = class extends Subscribable {
-  #online = true;
-  #cleanup;
-  #setup;
-  constructor() {
-    super();
-    this.#setup = onOnline => {
-      if (!isServer && window.addEventListener) {
-        const onlineListener = () => onOnline(true);
-        const offlineListener = () => onOnline(false);
-        window.addEventListener("online", onlineListener, false);
-        window.addEventListener("offline", offlineListener, false);
-        return () => {
-          window.removeEventListener("online", onlineListener);
-          window.removeEventListener("offline", offlineListener);
-        };
-      }
-      return;
-    };
-  }
-  onSubscribe() {
-    if (!this.#cleanup) {
-      this.setEventListener(this.#setup);
-    }
-  }
-  onUnsubscribe() {
-    if (!this.hasListeners()) {
-      this.#cleanup?.();
-      this.#cleanup = void 0;
-    }
-  }
-  setEventListener(setup) {
-    this.#setup = setup;
-    this.#cleanup?.();
-    this.#cleanup = setup(this.setOnline.bind(this));
-  }
-  setOnline(online) {
-    const changed = this.#online !== online;
-    if (changed) {
-      this.#online = online;
-      this.listeners.forEach(listener => {
-        listener(online);
-      });
-    }
-  }
-  isOnline() {
-    return this.#online;
-  }
-};
-var onlineManager = new OnlineManager();// src/retryer.ts
-function canFetch(networkMode) {
-  return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
-}// src/query.ts
-function fetchState(data, options) {
-  return {
-    fetchFailureCount: 0,
-    fetchFailureReason: null,
-    fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
-    ...(data === void 0 && {
-      error: null,
-      status: "pending"
-    })
-  };
-}// src/queryObserver.ts
-var QueryObserver = class extends Subscribable {
-  constructor(client, options) {
-    super();
-    this.options = options;
-    this.#client = client;
-    this.#selectError = null;
-    this.#currentThenable = pendingThenable();
-    this.bindMethods();
-    this.setOptions(options);
-  }
-  #client;
-  #currentQuery = void 0;
-  #currentQueryInitialState = void 0;
-  #currentResult = void 0;
-  #currentResultState;
-  #currentResultOptions;
-  #currentThenable;
-  #selectError;
-  #selectFn;
-  #selectResult;
-  // 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.
-  #lastQueryWithDefinedData;
-  #staleTimeoutId;
-  #refetchIntervalId;
-  #currentRefetchInterval;
-  #trackedProps = /* @__PURE__ */new Set();
-  bindMethods() {
-    this.refetch = this.refetch.bind(this);
-  }
-  onSubscribe() {
-    if (this.listeners.size === 1) {
-      this.#currentQuery.addObserver(this);
-      if (shouldFetchOnMount(this.#currentQuery, this.options)) {
-        this.#executeFetch();
-      } else {
-        this.updateResult();
-      }
-      this.#updateTimers();
-    }
-  }
-  onUnsubscribe() {
-    if (!this.hasListeners()) {
-      this.destroy();
-    }
-  }
-  shouldFetchOnReconnect() {
-    return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnReconnect);
-  }
-  shouldFetchOnWindowFocus() {
-    return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnWindowFocus);
-  }
-  destroy() {
-    this.listeners = /* @__PURE__ */new Set();
-    this.#clearStaleTimeout();
-    this.#clearRefetchInterval();
-    this.#currentQuery.removeObserver(this);
-  }
-  setOptions(options) {
-    const prevOptions = this.options;
-    const prevQuery = this.#currentQuery;
-    this.options = this.#client.defaultQueryOptions(options);
-    if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, this.#currentQuery) !== "boolean") {
-      throw new Error("Expected enabled to be a boolean or a callback that returns a boolean");
-    }
-    this.#updateQuery();
-    this.#currentQuery.setOptions(this.options);
-    if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
-      this.#client.getQueryCache().notify({
-        type: "observerOptionsUpdated",
-        query: this.#currentQuery,
-        observer: this
-      });
-    }
-    const mounted = this.hasListeners();
-    if (mounted && shouldFetchOptionally(this.#currentQuery, prevQuery, this.options, prevOptions)) {
-      this.#executeFetch();
-    }
-    this.updateResult();
-    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) {
-      this.#updateStaleTimeout();
-    }
-    const nextRefetchInterval = this.#computeRefetchInterval();
-    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) {
-      this.#updateRefetchInterval(nextRefetchInterval);
-    }
-  }
-  getOptimisticResult(options) {
-    const query = this.#client.getQueryCache().build(this.#client, options);
-    const result = this.createResult(query, options);
-    if (shouldAssignObserverCurrentProperties(this, result)) {
-      this.#currentResult = result;
-      this.#currentResultOptions = this.options;
-      this.#currentResultState = this.#currentQuery.state;
-    }
-    return result;
-  }
-  getCurrentResult() {
-    return this.#currentResult;
-  }
-  trackResult(result, onPropTracked) {
-    return new Proxy(result, {
-      get: (target, key) => {
-        this.trackProp(key);
-        onPropTracked?.(key);
-        if (key === "promise") {
-          this.trackProp("data");
-          if (!this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") {
-            this.#currentThenable.reject(new Error("experimental_prefetchInRender feature flag is not enabled"));
-          }
-        }
-        return Reflect.get(target, key);
-      }
-    });
-  }
-  trackProp(key) {
-    this.#trackedProps.add(key);
-  }
-  getCurrentQuery() {
-    return this.#currentQuery;
-  }
-  refetch({
-    ...options
-  } = {}) {
-    return this.fetch({
-      ...options
-    });
-  }
-  fetchOptimistic(options) {
-    const defaultedOptions = this.#client.defaultQueryOptions(options);
-    const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
-    return query.fetch().then(() => this.createResult(query, defaultedOptions));
-  }
-  fetch(fetchOptions) {
-    return this.#executeFetch({
-      ...fetchOptions,
-      cancelRefetch: fetchOptions.cancelRefetch ?? true
-    }).then(() => {
-      this.updateResult();
-      return this.#currentResult;
-    });
-  }
-  #executeFetch(fetchOptions) {
-    this.#updateQuery();
-    let promise = this.#currentQuery.fetch(this.options, fetchOptions);
-    if (!fetchOptions?.throwOnError) {
-      promise = promise.catch(noop);
-    }
-    return promise;
-  }
-  #updateStaleTimeout() {
-    this.#clearStaleTimeout();
-    const staleTime = resolveStaleTime(this.options.staleTime, this.#currentQuery);
-    if (isServer || this.#currentResult.isStale || !isValidTimeout(staleTime)) {
-      return;
-    }
-    const time = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime);
-    const timeout = time + 1;
-    this.#staleTimeoutId = timeoutManager.setTimeout(() => {
-      if (!this.#currentResult.isStale) {
-        this.updateResult();
-      }
-    }, timeout);
-  }
-  #computeRefetchInterval() {
-    return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false;
-  }
-  #updateRefetchInterval(nextInterval) {
-    this.#clearRefetchInterval();
-    this.#currentRefetchInterval = nextInterval;
-    if (isServer || resolveEnabled(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
-      return;
-    }
-    this.#refetchIntervalId = timeoutManager.setInterval(() => {
-      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
-        this.#executeFetch();
-      }
-    }, this.#currentRefetchInterval);
-  }
-  #updateTimers() {
-    this.#updateStaleTimeout();
-    this.#updateRefetchInterval(this.#computeRefetchInterval());
-  }
-  #clearStaleTimeout() {
-    if (this.#staleTimeoutId) {
-      timeoutManager.clearTimeout(this.#staleTimeoutId);
-      this.#staleTimeoutId = void 0;
-    }
-  }
-  #clearRefetchInterval() {
-    if (this.#refetchIntervalId) {
-      timeoutManager.clearInterval(this.#refetchIntervalId);
-      this.#refetchIntervalId = void 0;
-    }
-  }
-  createResult(query, options) {
-    const prevQuery = this.#currentQuery;
-    const prevOptions = this.options;
-    const prevResult = this.#currentResult;
-    const prevResultState = this.#currentResultState;
-    const prevResultOptions = this.#currentResultOptions;
-    const queryChange = query !== prevQuery;
-    const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
-    const {
-      state
-    } = query;
-    let newState = {
-      ...state
-    };
-    let isPlaceholderData = false;
-    let data;
-    if (options._optimisticResults) {
-      const mounted = this.hasListeners();
-      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
-      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
-      if (fetchOnMount || fetchOptionally) {
-        newState = {
-          ...newState,
-          ...fetchState(state.data, query.options)
-        };
-      }
-      if (options._optimisticResults === "isRestoring") {
-        newState.fetchStatus = "idle";
-      }
-    }
-    let {
-      error,
-      errorUpdatedAt,
-      status
-    } = newState;
-    data = newState.data;
-    let skipSelect = false;
-    if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
-      let placeholderData;
-      if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
-        placeholderData = prevResult.data;
-        skipSelect = true;
-      } else {
-        placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(this.#lastQueryWithDefinedData?.state.data, this.#lastQueryWithDefinedData) : options.placeholderData;
-      }
-      if (placeholderData !== void 0) {
-        status = "success";
-        data = replaceData(prevResult?.data, placeholderData, options);
-        isPlaceholderData = true;
-      }
-    }
-    if (options.select && data !== void 0 && !skipSelect) {
-      if (prevResult && data === prevResultState?.data && options.select === this.#selectFn) {
-        data = this.#selectResult;
-      } else {
-        try {
-          this.#selectFn = options.select;
-          data = options.select(data);
-          data = replaceData(prevResult?.data, data, options);
-          this.#selectResult = data;
-          this.#selectError = null;
-        } catch (selectError) {
-          this.#selectError = selectError;
-        }
-      }
-    }
-    if (this.#selectError) {
-      error = this.#selectError;
-      data = this.#selectResult;
-      errorUpdatedAt = Date.now();
-      status = "error";
-    }
-    const isFetching = newState.fetchStatus === "fetching";
-    const isPending = status === "pending";
-    const isError = status === "error";
-    const isLoading = isPending && isFetching;
-    const hasData = data !== void 0;
-    const result = {
-      status,
-      fetchStatus: newState.fetchStatus,
-      isPending,
-      isSuccess: status === "success",
-      isError,
-      isInitialLoading: isLoading,
-      isLoading,
-      data,
-      dataUpdatedAt: newState.dataUpdatedAt,
-      error,
-      errorUpdatedAt,
-      failureCount: newState.fetchFailureCount,
-      failureReason: newState.fetchFailureReason,
-      errorUpdateCount: newState.errorUpdateCount,
-      isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,
-      isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
-      isFetching,
-      isRefetching: isFetching && !isPending,
-      isLoadingError: isError && !hasData,
-      isPaused: newState.fetchStatus === "paused",
-      isPlaceholderData,
-      isRefetchError: isError && hasData,
-      isStale: isStale(query, options),
-      refetch: this.refetch,
-      promise: this.#currentThenable,
-      isEnabled: resolveEnabled(options.enabled, query) !== false
-    };
-    const nextResult = result;
-    if (this.options.experimental_prefetchInRender) {
-      const hasResultData = nextResult.data !== void 0;
-      const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
-      const finalizeThenableIfPossible = thenable => {
-        if (isErrorWithoutData) {
-          thenable.reject(nextResult.error);
-        } else if (hasResultData) {
-          thenable.resolve(nextResult.data);
-        }
-      };
-      const recreateThenable = () => {
-        const pending = this.#currentThenable = nextResult.promise = pendingThenable();
-        finalizeThenableIfPossible(pending);
-      };
-      const prevThenable = this.#currentThenable;
-      switch (prevThenable.status) {
-        case "pending":
-          if (query.queryHash === prevQuery.queryHash) {
-            finalizeThenableIfPossible(prevThenable);
-          }
-          break;
-        case "fulfilled":
-          if (isErrorWithoutData || nextResult.data !== prevThenable.value) {
-            recreateThenable();
-          }
-          break;
-        case "rejected":
-          if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) {
-            recreateThenable();
-          }
-          break;
-      }
-    }
-    return nextResult;
-  }
-  updateResult() {
-    const prevResult = this.#currentResult;
-    const nextResult = this.createResult(this.#currentQuery, this.options);
-    this.#currentResultState = this.#currentQuery.state;
-    this.#currentResultOptions = this.options;
-    if (this.#currentResultState.data !== void 0) {
-      this.#lastQueryWithDefinedData = this.#currentQuery;
-    }
-    if (shallowEqualObjects(nextResult, prevResult)) {
-      return;
-    }
-    this.#currentResult = nextResult;
-    const shouldNotifyListeners = () => {
-      if (!prevResult) {
-        return true;
-      }
-      const {
-        notifyOnChangeProps
-      } = this.options;
-      const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
-      if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !this.#trackedProps.size) {
-        return true;
-      }
-      const includedProps = new Set(notifyOnChangePropsValue ?? this.#trackedProps);
-      if (this.options.throwOnError) {
-        includedProps.add("error");
-      }
-      return Object.keys(this.#currentResult).some(key => {
-        const typedKey = key;
-        const changed = this.#currentResult[typedKey] !== prevResult[typedKey];
-        return changed && includedProps.has(typedKey);
-      });
-    };
-    this.#notify({
-      listeners: shouldNotifyListeners()
-    });
-  }
-  #updateQuery() {
-    const query = this.#client.getQueryCache().build(this.#client, this.options);
-    if (query === this.#currentQuery) {
-      return;
-    }
-    const prevQuery = this.#currentQuery;
-    this.#currentQuery = query;
-    this.#currentQueryInitialState = query.state;
-    if (this.hasListeners()) {
-      prevQuery?.removeObserver(this);
-      query.addObserver(this);
-    }
-  }
-  onQueryUpdate() {
-    this.updateResult();
-    if (this.hasListeners()) {
-      this.#updateTimers();
-    }
-  }
-  #notify(notifyOptions) {
-    notifyManager.batch(() => {
-      if (notifyOptions.listeners) {
-        this.listeners.forEach(listener => {
-          listener(this.#currentResult);
-        });
-      }
-      this.#client.getQueryCache().notify({
-        query: this.#currentQuery,
-        type: "observerResultsUpdated"
-      });
-    });
-  }
-};
-function shouldLoadOnMount(query, options) {
-  return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
-}
-function shouldFetchOnMount(query, options) {
-  return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
-}
-function shouldFetchOn(query, options, field) {
-  if (resolveEnabled(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
-    const value = typeof field === "function" ? field(query) : field;
-    return value === "always" || value !== false && isStale(query, options);
-  }
-  return false;
-}
-function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
-  return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
-}
-function isStale(query, options) {
-  return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
-}
-function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
-  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
-    return true;
-  }
-  return false;
 }const usePageFormManager = ({
   form,
   pageId,