@gaddario98/react-core 2.0.8 → 2.0.9

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,Fragment,jsxs}from'react/jsx-runtime';import {useRef,useEffect,useReducer,useCallback,useMemo,useState,memo,createContext,useContext}from'react';import {atom,useAtom,useSetAtom,useAtomValue,useStore}from'jotai';import {atomWithStorage,createJSONStorage,selectAtom}from'jotai/utils';import {inflateSync,strFromU8,strToU8,deflateSync}from'fflate';import {c}from'react/compiler-runtime';import {QueryClient,useQueries,QueryObserver}from'@tanstack/react-query';import axios from'axios';import equal from'fast-deep-equal';import {atomFamily}from'jotai-family';import {useForm}from'@tanstack/react-form';/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -25,839 +25,1594 @@ 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 RAW_PREFIX = 'storage:raw:';
+const DEFLATE_PREFIX = 'storage:deflate:v1:';
+const isProbablyJson = value => {
+  if (!value) return false;
+  const c = value.charCodeAt(0);
+  // { [ " digits, t/f/n (true/false/null)
+  return c === 123 || c === 91 || c === 34 || c >= 48 && c <= 57 || c === 45 || c === 116 || c === 102 || c === 110;
 };
-const BUILDING_BLOCK_atomOnMount = (_store, atom, setAtom) => {
-  var _a;
-  return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
+const u8ToBase64 = bytes => {
+  let binary = '';
+  const chunkSize = 0x8000;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+  }
+  return btoa(binary);
 };
-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 base64ToU8 = base64 => {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
 };
-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);
+const createCompressedStorage = (base, options = {}) => {
+  const {
+    minSizeToCompress = 1024,
+    deflateLevel = 1,
+    writeDebounceMs = 50
+  } = options;
+  const pendingWrites = new Map();
+  let flushTimer;
+  let lifecycleHooksInstalled = false;
+  const flush = () => {
+    flushTimer = undefined;
+    for (const [key, value] of pendingWrites) {
+      try {
+        if (value.length < minSizeToCompress) {
+          base.setItem(key, RAW_PREFIX + value);
+          continue;
+        }
+        const input = strToU8(value);
+        const compressed = deflateSync(input, {
+          level: deflateLevel
+        });
+        base.setItem(key, DEFLATE_PREFIX + u8ToBase64(compressed));
+      } catch (error) {
+        console.error('Error setting item:', error);
+        try {
+          base.setItem(key, RAW_PREFIX + value);
+        } catch (_a) {
+          // ignore
+        }
+      }
     }
+    pendingWrites.clear();
   };
-  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;
+  const scheduleFlush = () => {
+    if (flushTimer != null) return;
+    if (!lifecycleHooksInstalled && typeof window !== 'undefined') {
+      lifecycleHooksInstalled = true;
+      window.addEventListener('beforeunload', flush);
+      document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') flush();
+      });
     }
-    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");
+    flushTimer = globalThis.setTimeout(flush, writeDebounceMs);
+  };
+  return {
+    getItem: key => {
+      try {
+        const stored = base.getItem(key);
+        if (!stored) return null;
+        if (stored.startsWith(RAW_PREFIX)) {
+          return stored.slice(RAW_PREFIX.length);
+        }
+        if (stored.startsWith(DEFLATE_PREFIX)) {
+          const b64 = stored.slice(DEFLATE_PREFIX.length);
+          const bytes = base64ToU8(b64);
+          const decompressed = inflateSync(bytes);
+          return strFromU8(decompressed);
+        }
+        // Back-compat: older versions may have stored raw JSON without any prefix
+        if (isProbablyJson(stored)) return stored;
+        return null;
+      } catch (error) {
+        console.error('Error getting item:', error);
+        return null;
       }
-      visited.add(a);
-      stack.pop();
-      continue;
-    }
-    visiting.add(a);
-    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      if (!visiting.has(d)) {
-        stack.push(d);
+    },
+    setItem: (key, value) => {
+      try {
+        // Some upstream serializers can return `undefined` (e.g. JSON.stringify(undefined)).
+        const rawValue = value;
+        if (rawValue == null) {
+          pendingWrites.delete(key);
+          base.removeItem(key);
+          return;
+        }
+        const stringValue = typeof rawValue === 'string' ? rawValue : String(rawValue);
+        pendingWrites.set(key, stringValue);
+        scheduleFlush();
+      } catch (error) {
+        console.error('Error setting item:', error);
       }
-    }
-  }
-  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;
+    },
+    removeItem: key => {
+      try {
+        pendingWrites.delete(key);
+        base.removeItem(key);
+      } catch (error) {
+        console.error('Error removing item:', error);
       }
     }
-    if (hasChangedDeps) {
-      readAtomState(store, a);
-      mountDependencies(store, a);
-    }
-    invalidatedAtoms.delete(a);
+  };
+};
+const baseStorage = {
+  getItem: key => {
+    if (typeof localStorage === 'undefined') return null;
+    return localStorage.getItem(key);
+  },
+  setItem: (key, value) => {
+    if (typeof localStorage === 'undefined') return;
+    localStorage.setItem(key, value);
+  },
+  removeItem: key => {
+    if (typeof localStorage === 'undefined') return;
+    localStorage.removeItem(key);
   }
 };
-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;
-      }
+let storage = createCompressedStorage(baseStorage);// Implementazione
+function atomStateGenerator({
+  key,
+  defaultValue,
+  persist = false,
+  storage: customStorage
+}) {
+  const resolvedStorage = customStorage || storage;
+  // Usa atomWithStorage solo se persist è true, altrimenti atom normale
+  const jotaiAtom = persist ? atomWithStorage(key, defaultValue, createJSONStorage(() => resolvedStorage)) : atom(defaultValue);
+  const useValue = () => {
+    const [value] = useAtom(jotaiAtom);
+    return value;
+  };
+  const useState = () => {
+    const $ = c(3);
+    const [value, setValue] = useAtom(jotaiAtom);
+    let t0;
+    if ($[0] !== setValue || $[1] !== value) {
+      t0 = [value, setValue];
+      $[0] = setValue;
+      $[1] = value;
+      $[2] = t0;
+    } else {
+      t0 = $[2];
     }
-    if (!hasChangedDeps) {
-      return atomState;
+    return t0;
+  };
+  const useReset = () => {
+    const $ = c(2);
+    const [, setValue] = useAtom(jotaiAtom);
+    let t0;
+    if ($[0] !== setValue) {
+      t0 = () => {
+        setValue(defaultValue);
+        if (persist) {
+          resolvedStorage.removeItem(key);
+        }
+      };
+      $[0] = setValue;
+      $[1] = t0;
+    } else {
+      t0 = $[1];
     }
+    return t0;
+  };
+  return {
+    atom: jotaiAtom,
+    useValue,
+    useState,
+    useReset
+  };
+}// ============================================================================
+// Default Values
+// ============================================================================
+const DEFAULT_QUERY_ENTRY = Object.freeze({
+  data: undefined,
+  isLoading: false,
+  isLoadingMapped: false,
+  isFetching: false,
+  isPending: false,
+  isSuccess: false,
+  isError: false,
+  isStale: false,
+  error: null,
+  dataUpdatedAt: 0,
+  errorUpdatedAt: 0,
+  fetchStatus: 'idle',
+  refetch: () => Promise.resolve()
+});
+const DEFAULT_MUTATION_ENTRY = Object.freeze({
+  data: undefined,
+  status: 'idle',
+  error: null,
+  variables: undefined,
+  submittedAt: 0,
+  isIdle: true,
+  isPending: false,
+  isSuccess: false,
+  isError: false,
+  mutate: () => {},
+  mutateAsync: async () => Promise.resolve(undefined),
+  reset: () => {},
+  context: 0,
+  failureCount: 0,
+  failureReason: null,
+  isPaused: false
+});
+// ============================================================================
+// Global Atoms (single atom for all queries, single atom for all mutations)
+// ============================================================================
+/**
+ * Global atom storing all query results.
+ * Key format: "scopeId:queryKey"
+ */
+const queriesAtom = atomWithStorage('queries-atom', {}, createJSONStorage(() => storage), {
+  getOnInit: true
+});
+/**
+ * Global atom storing all mutation results.
+ * Key format: "scopeId:mutationKey"
+ */
+const mutationsAtom = atom({});
+// ============================================================================
+// Helper to generate composite keys
+// ============================================================================
+const getCompositeKey = (scopeId, key) => `${scopeId}:${key}`;const apiClient = axios.create({
+  timeout: 30000,
+  headers: {
+    'Content-Type': 'application/json'
   }
-  atomState.d.clear();
-  let isSync = true;
-  function mountDependenciesIfAsync() {
-    if (mountedMap.has(atom)) {
-      mountDependencies(store, atom);
-      recomputeInvalidatedAtoms(store);
-      flushCallbacks(store);
-    }
+});
+apiClient.interceptors.response.use(response => response, error => {
+  var _a, _b;
+  if (error.response) {
+    throw new Error(((_a = error.response.data) === null || _a === void 0 ? void 0 : _a.message) || ((_b = error.response.data) === null || _b === void 0 ? void 0 : _b.error) || `Error ${error.response.status}`);
+  } else if (error.request) {
+    throw new Error('No response from server - request timeout or network issue');
+  } else {
+    throw new Error('Request configuration error');
   }
-  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();
+});
+const apiRequest = async ({
+  method,
+  url,
+  body,
+  headers,
+  converter
+}) => {
+  try {
+    const isPrimitive = typeof body === 'string' || typeof body === 'number' || typeof body === 'boolean';
+    let finalUrl = url;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let finalBody = body;
+    // 1. Primitive Body Handling (Append to URL)
+    if (isPrimitive && body) {
+      if (method !== 'POST') {
+        finalUrl = `${url}/${body}`;
+        finalBody = undefined;
       }
     }
-  }
-  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);
+    // 2. Object Body Handling (Path Param Replacement)
+    if (!isPrimitive && typeof body === 'object' && body !== null) {
+      // Look for :param in string
+      // e.g. /users/:uid/availability
+      const pathParams = finalUrl.match(/:[a-zA-Z0-9_]+/g);
+      if (pathParams) {
+        // Create shallow copy to avoid mutating original
+        finalBody = Object.assign({}, body);
+        pathParams.forEach(param => {
+          if (finalBody) {
+            const key = param.substring(1); // remove :
+            if (key in finalBody) {
+              finalUrl = finalUrl.replace(param, String(finalBody[key]));
+              // Optional: remove from body if it was used in path?
+              // Usually yes for simple IDs, maybe not for others.
+              // Let's remove to keep body clean.
+              delete finalBody[key];
             }
           }
-        };
+        });
+      }
+      // Also handle case where we append ID to end if URL ends with / and we have 'id' or 'uid' in body?
+      // No, explicit :param or explicit append logic is safer.
+      // But we have logic for 'updateUser' where we just set endpoint ['api', 'users'] and method PUT.
+      // We expect /users/123.
+      // If body is { uid: 123, ...data }, we want /users/123.
+      // If no :param is found, and method is PUT/DELETE/PATCH, and body has 'id' or 'uid', should we append?
+      // User asked to eliminate customRequest.
+      // Let's add: "If method is PUT/DELETE/PATCH, and no :param replacement happened, and body has (id|uid), append it."
+      const hasId = 'id' in finalBody || 'uid' in finalBody;
+      if ((method === 'PUT' || method === 'DELETE' || method === 'PATCH') && hasId && !pathParams) {
+        const id = finalBody.id || finalBody.uid;
+        if (id) {
+          finalUrl = `${finalUrl}/${id}`;
+          // We generally DON'T remove ID from body in this implicit case as it might be needed for validation
+          // But for cleaner API calls we might want to.
+          // Let's keep it safe: Don't remove ID here.
+        }
       }
-      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);
+    const data = converter && finalBody ? converter(finalBody) : finalBody;
+    const response = await apiClient({
+      url: finalUrl,
+      method,
+      data,
+      headers
+    });
+    if (response.status >= 200 && response.status < 300) {
+      return response.data;
     }
-    (_a = storeHooks.r) == null ? void 0 : _a.call(storeHooks, atom);
-    return atomState;
+    throw new Error(`Request failed with status ${response.status}`);
   } 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);
+    console.error('API Request Error:', error);
+    if (error instanceof Error) {
+      throw error;
     }
+    throw new Error('Unknown error occurred');
   }
+};const _endpoints = {
+  custom: '',
+  api: 'http://localhost:3000' // import.meta.env.VITE_API_URL ||
 };
-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 defaultQueryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      retry: 2
+      //  staleTime: 2 * 60 * 1000,
     }
   }
-};
-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");
+});
+const {
+  useValue: useApiConfigValue} = atomStateGenerator({
+  key: 'apiConfig',
+  defaultValue: {
+    endpoints: _endpoints,
+    requestFn: apiRequest,
+    queryClient: defaultQueryClient
+  },
+  persist: false
+});const useMultipleQuery = t0 => {
+  const $ = c(30);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === undefined ? [] : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const settings = t1;
+  const {
+    requestFn,
+    validateAuthFn,
+    defaultHeaders,
+    queryClient,
+    endpoints
+  } = useApiConfigValue();
+  let t2;
+  if ($[2] !== endpoints) {
+    t2 = endpoint => {
+      const [key, path] = endpoint;
+      const baseUrl = endpoints[key];
+      return [baseUrl, path].filter(Boolean).join("/");
+    };
+    $[2] = endpoints;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const generateEndpoint = t2;
+  let t3;
+  if ($[4] !== validateAuthFn) {
+    t3 = validateAuthFn ? validateAuthFn() : true;
+    $[4] = validateAuthFn;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const isLogged = t3;
+  let t4;
+  if ($[6] !== defaultHeaders || $[7] !== generateEndpoint || $[8] !== requestFn) {
+    t4 = async t5 => {
+      const {
+        endpoint: endpoint_0,
+        customQueryFn,
+        headers
+      } = t5;
+      const fullEndpoint = generateEndpoint(endpoint_0);
+      if (customQueryFn) {
+        const res = await customQueryFn();
+        return res;
+      }
+      const mergedHeaders = Object.assign(Object.assign({}, defaultHeaders), headers);
+      return await requestFn({
+        url: fullEndpoint,
+        method: "GET",
+        headers: mergedHeaders
+      });
+    };
+    $[6] = defaultHeaders;
+    $[7] = generateEndpoint;
+    $[8] = requestFn;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  const generateQueryFn = t4;
+  let t5;
+  let t6;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = {};
+    t6 = {};
+    $[10] = t5;
+    $[11] = t6;
+  } else {
+    t5 = $[10];
+    t6 = $[11];
+  }
+  let t7;
+  if ($[12] !== settings) {
+    t7 = {
+      settings,
+      data: t5,
+      results: t6
+    };
+    $[12] = settings;
+    $[13] = t7;
+  } else {
+    t7 = $[13];
+  }
+  const ref = useRef(t7);
+  let t8;
+  let t9;
+  if ($[14] !== settings) {
+    t8 = () => {
+      ref.current.settings = settings;
+    };
+    t9 = [settings];
+    $[14] = settings;
+    $[15] = t8;
+    $[16] = t9;
+  } else {
+    t8 = $[15];
+    t9 = $[16];
+  }
+  useEffect(t8, t9);
+  let t10;
+  if ($[17] !== generateQueryFn || $[18] !== isLogged || $[19] !== settings) {
+    let t11;
+    if ($[21] !== generateQueryFn || $[22] !== isLogged) {
+      t11 = setting => {
+        const {
+          queryKey,
+          enabled: t12,
+          disableAuthControl
+        } = setting;
+        const enabled = t12 === undefined ? true : t12;
+        const rest = __rest(setting, ["queryKey", "enabled", "disableAuthControl"]);
+        return Object.assign({
+          queryKey,
+          queryFn: () => generateQueryFn(setting),
+          enabled: !!enabled && (disableAuthControl || !!isLogged)
+        }, rest);
+      };
+      $[21] = generateQueryFn;
+      $[22] = isLogged;
+      $[23] = t11;
+    } else {
+      t11 = $[23];
+    }
+    t10 = settings.map(t11);
+    $[17] = generateQueryFn;
+    $[18] = isLogged;
+    $[19] = settings;
+    $[20] = t10;
+  } else {
+    t10 = $[20];
+  }
+  const queries = t10;
+  let t11;
+  if ($[24] === Symbol.for("react.memo_cache_sentinel")) {
+    t11 = results => results.reduce((prev, result, index) => {
+      const setting_0 = ref.current.settings[index];
+      const keyToMap = setting_0.keyToMap;
+      Object.assign(prev, {
+        [keyToMap]: {
+          data: result.data,
+          isLoadingMapped: !setting_0.disableLoading && result.isLoading,
+          isLoading: result.isLoading,
+          isFetching: result.isFetching,
+          isPending: result.isPending,
+          error: result.error,
+          refetch: result.refetch
         }
-        if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-          storeMutationSet.add(store);
+      });
+      return prev;
+    }, {});
+    $[24] = t11;
+  } else {
+    t11 = $[24];
+  }
+  const combine = t11;
+  let t12;
+  if ($[25] !== queries) {
+    t12 = {
+      queries,
+      combine
+    };
+    $[25] = queries;
+    $[26] = t12;
+  } else {
+    t12 = $[26];
+  }
+  const result_0 = useQueries(t12, queryClient);
+  let t13;
+  let t14;
+  if ($[27] !== result_0) {
+    t13 = () => {
+      ref.current.settings.forEach(setting_1 => {
+        const {
+          keyToMap: keyToMap_0,
+          onDataChanged,
+          onStateChange
+        } = setting_1;
+        if (!onDataChanged && !onStateChange) {
+          return;
         }
-        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);
+        const currentResult = result_0[keyToMap_0];
+        const prevResult = ref.current.results[keyToMap_0];
+        if (onStateChange) {
+          if (!prevResult || prevResult.data !== currentResult.data || prevResult.isLoading !== currentResult.isLoading || prevResult.isLoadingMapped !== currentResult.isLoadingMapped || prevResult.isFetching !== currentResult.isFetching || prevResult.isPending !== currentResult.isPending || prevResult.error !== currentResult.error) {
+            ref.current.results[keyToMap_0] = currentResult;
+            onStateChange(currentResult);
+          }
         }
-        return void 0;
+        if (onDataChanged) {
+          const currentData = currentResult.data;
+          const prevData = ref.current.data[keyToMap_0];
+          if (currentData !== undefined && currentData !== prevData) {
+            ref.current.data[keyToMap_0] = currentData;
+            onDataChanged(currentData);
+          }
+        }
+      });
+    };
+    t14 = [result_0];
+    $[27] = result_0;
+    $[28] = t13;
+    $[29] = t14;
+  } else {
+    t13 = $[28];
+    t14 = $[29];
+  }
+  useEffect(t13, t14);
+  return result_0;
+};/* eslint-disable @typescript-eslint/no-explicit-any */
+const defaultState = DEFAULT_MUTATION_ENTRY;
+const mutationReducer = (state, action) => {
+  switch (action.type) {
+    case "RESET":
+      return Object.assign(Object.assign({}, state), {
+        [action.key]: Object.assign({}, defaultState)
+      });
+    case "PENDING":
+      return Object.assign(Object.assign({}, state), {
+        [action.key]: {
+          status: "pending",
+          data: undefined,
+          error: null,
+          submittedAt: action.submittedAt,
+          variables: action.variables
+        }
+      });
+    case "SUCCESS":
+      return Object.assign(Object.assign({}, state), {
+        [action.key]: Object.assign(Object.assign({}, state[action.key]), {
+          status: "success",
+          data: action.data,
+          error: null
+        })
+      });
+    case "ERROR":
+      return Object.assign(Object.assign({}, state), {
+        [action.key]: Object.assign(Object.assign({}, state[action.key]), {
+          status: "error",
+          error: action.error
+        })
+      });
+    default:
+      return state;
+  }
+};
+const initMutationStates = configs => {
+  const states = {};
+  configs.forEach(config => {
+    states[config.key] = Object.assign({}, defaultState);
+  });
+  return states;
+};
+const useMultipleMutation = configs => {
+  const {
+    requestFn,
+    validateAuthFn,
+    defaultHeaders,
+    queryClient,
+    showNotification,
+    endpoints
+  } = useApiConfigValue();
+  const [reducerStates, dispatchReducer] = useReducer(mutationReducer, configs, initMutationStates);
+  // Accessor for current state
+  const getState = useCallback(key => {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return reducerStates[key] || defaultState;
+  }, [reducerStates]);
+  // Dispatcher that handles both modes
+  const dispatch = useCallback(action => {
+    dispatchReducer(action);
+  }, []);
+  const executeMutation = useCallback(async (key_0, config, data, mutationOptions) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const {
+      endpoint,
+      method,
+      headers,
+      queryKeyToInvalidate,
+      customRequest,
+      converter,
+      isTest,
+      notification,
+      mutateOptions
+    } = config;
+    dispatch({
+      type: "PENDING",
+      key: key_0,
+      submittedAt: Date.now(),
+      variables: data
+    });
+    let context;
+    try {
+      // Auth validation
+      const isValidAuth = validateAuthFn ? validateAuthFn() : true;
+      if (!isValidAuth) {
+        throw new Error("Utente non autenticato");
+      }
+      // Build endpoint
+      const [endpointKey, path] = endpoint;
+      const baseUrl = (_a = endpoints[endpointKey]) !== null && _a !== void 0 ? _a : "";
+      const fullEndpoint = [baseUrl, path].filter(Boolean).join("/");
+      // Merge headers
+      const mergedHeaders = Object.assign(Object.assign({}, defaultHeaders), headers);
+      // Execute request
+      let result;
+      if (isTest) {
+        result = "test";
+      } else if (customRequest) {
+        result = await customRequest(fullEndpoint, method, data);
       } else {
-        return writeAtomState(store, a, ...args2);
+        result = await requestFn({
+          url: fullEndpoint,
+          method,
+          body: data,
+          headers: mergedHeaders,
+          converter
+        });
       }
-    } finally {
-      if (!isSync) {
-        recomputeInvalidatedAtoms(store);
-        flushCallbacks(store);
+      dispatch({
+        type: "SUCCESS",
+        key: key_0,
+        data: result
+      });
+      // Invalidate queries
+      if (queryKeyToInvalidate) {
+        queryKeyToInvalidate.forEach(qKey => {
+          queryClient.invalidateQueries({
+            queryKey: [qKey],
+            exact: false
+          });
+        });
       }
-    }
-  };
-  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);
-        }
+      // Success notification
+      const notificationProps_0 = typeof (notification === null || notification === void 0 ? void 0 : notification.success) === "function" ? notification.success(result) : notification === null || notification === void 0 ? void 0 : notification.success;
+      if (notificationProps_0 === null || notificationProps_0 === void 0 ? void 0 : notificationProps_0.message) {
+        showNotification === null || showNotification === void 0 ? void 0 : showNotification(Object.assign({
+          message: notificationProps_0.message,
+          type: (_b = notificationProps_0.type) !== null && _b !== void 0 ? _b : "success"
+        }, notificationProps_0));
       }
-    }
-    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);
+      // Callbacks
+      // @ts-expect-error - MutateOptions callback signature varies by TanStack Query version
+      (_c = mutateOptions === null || mutateOptions === void 0 ? void 0 : mutateOptions.onSuccess) === null || _c === void 0 ? void 0 : _c.call(mutateOptions, result, data, context);
+      (_d = mutationOptions === null || mutationOptions === void 0 ? void 0 : mutationOptions.onSuccess) === null || _d === void 0 ? void 0 : _d.call(mutationOptions, result, data, undefined, context);
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error("Unknown error");
+      dispatch({
+        type: "ERROR",
+        key: key_0,
+        error: err
+      });
+      // Error notification
+      const notificationProps = typeof (notification === null || notification === void 0 ? void 0 : notification.error) === "function" ? notification.error(err.message) : notification === null || notification === void 0 ? void 0 : notification.error;
+      if ((notificationProps === null || notificationProps === void 0 ? void 0 : notificationProps.message) || err.message) {
+        showNotification === null || showNotification === void 0 ? void 0 : showNotification(Object.assign({
+          message: (notificationProps === null || notificationProps === void 0 ? void 0 : notificationProps.message) || err.message || "An unexpected error occurred",
+          type: (_e = notificationProps === null || notificationProps === void 0 ? void 0 : notificationProps.type) !== null && _e !== void 0 ? _e : "error"
+        }, notificationProps));
       }
-    }
-  }
-};
-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()
+      // Callbacks
+      // @ts-expect-error - MutateOptions callback signature varies by TanStack Query version
+      (_f = mutateOptions === null || mutateOptions === void 0 ? void 0 : mutateOptions.onError) === null || _f === void 0 ? void 0 : _f.call(mutateOptions, err, data, context);
+      (_g = mutationOptions === null || mutationOptions === void 0 ? void 0 : mutationOptions.onError) === null || _g === void 0 ? void 0 : _g.call(mutationOptions, err, data, undefined, context);
+      throw err;
+    }
+  }, [queryClient, validateAuthFn, defaultHeaders, endpoints, requestFn, showNotification, dispatch // dispatch is now stable/wrapped
+  ]);
+  const ref = useRef({
+    dispatch,
+    executeMutation
+  });
+  useEffect(() => {
+    ref.current = {
+      dispatch,
+      executeMutation
     };
-    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);
-            }
-          }
-        };
+  }, [dispatch, executeMutation]);
+  const allMutation = useMemo(() => {
+    const result_0 = {};
+    configs.forEach(item => {
+      var _a_0, _b_0, _c_0;
+      // In silent mode, this is just the INITIAL state (or whatever triggered last render).
+      // The real data comes from Proxy if used.
+      const state = getState(item.key);
+      const mutationConfig = item.mutationConfig;
+      const mutationKey = item.key;
+      result_0[mutationKey] = {
+        // State
+        data: state.data,
+        error: state.error,
+        isIdle: state.status === "idle",
+        isPending: state.status === "pending",
+        isSuccess: state.status === "success",
+        isError: state.status === "error",
+        status: state.status,
+        variables: state.variables,
+        submittedAt: (_a_0 = state.submittedAt) !== null && _a_0 !== void 0 ? _a_0 : 0,
+        endpoint: mutationConfig.endpoint,
+        // Methods
+        mutate: (data_0, mutationOptions_0) => {
+          ref.current.executeMutation(item.key, mutationConfig, data_0, mutationOptions_0);
+        },
+        mutateAsync: (data_1, mutationOptions_1) => {
+          return ref.current.executeMutation(item.key, mutationConfig, data_1, mutationOptions_1);
+        },
+        reset: () => ref.current.dispatch({
+          type: "RESET",
+          key: item.key
+        }),
+        // Compatibility fields
+        failureCount: 0,
+        failureReason: null,
+        context: undefined,
+        isPaused: false
+      };
+      (_c_0 = (_b_0 = item.mutationConfig).onStateChange) === null || _c_0 === void 0 ? void 0 : _c_0.call(_b_0, result_0[mutationKey]);
+    });
+    return result_0;
+  }, [getState, configs]);
+  return allMutation;
+};const useMultipleWebSocket = (configs = []) => {
+  const {
+    websocketConfig
+  } = useApiConfigValue();
+  const {
+    queryClient
+  } = useApiConfigValue();
+  const socketsRef = useRef(new Map());
+  const [statuses, setStatuses] = useState(new Map());
+  const [lastMessages, setLastMessages] = useState(new Map());
+  // Stabilize configs reference
+  const stableConfigs = useMemo(() => configs, [configs]);
+  useEffect(() => {
+    const sockets = socketsRef.current;
+    stableConfigs.forEach(config => {
+      const url = config.endpoint || (websocketConfig === null || websocketConfig === void 0 ? void 0 : websocketConfig.url);
+      const shouldConnect = config.autoConnect !== false && ((websocketConfig === null || websocketConfig === void 0 ? void 0 : websocketConfig.autoConnect) || config.endpoint);
+      if (!url || !shouldConnect) return;
+      // Skip if already connected
+      if (sockets.has(config.key)) return;
+      setStatuses(prev => new Map(prev).set(config.key, 'connecting'));
+      const ws = new WebSocket(url);
+      sockets.set(config.key, ws);
+      ws.onopen = () => {
+        setStatuses(prev_0 => new Map(prev_0).set(config.key, 'open'));
+        console.log(`WebSocket [${config.key}] connected`);
+      };
+      ws.onmessage = event => {
+        var _a, _b;
         try {
-          const onUnmount = atomOnMount(store, atom, setAtom);
-          if (onUnmount) {
-            mounted.u = () => {
-              isSync = true;
-              try {
-                onUnmount();
-              } finally {
-                isSync = false;
-              }
-            };
+          const data = JSON.parse(event.data);
+          setLastMessages(prev_1 => new Map(prev_1).set(config.key, data));
+          // Global handler
+          (_a = websocketConfig === null || websocketConfig === void 0 ? void 0 : websocketConfig.onMessage) === null || _a === void 0 ? void 0 : _a.call(websocketConfig, data);
+          // Local handler
+          (_b = config.onMessage) === null || _b === void 0 ? void 0 : _b.call(config, data);
+          // Auto invalidation
+          if (config.invalidateQueriesOnMessage && Array.isArray(config.invalidateQueriesOnMessage)) {
+            config.invalidateQueriesOnMessage.forEach(key => {
+              queryClient.invalidateQueries({
+                queryKey: [key],
+                exact: false
+              });
+            });
           }
-        } finally {
-          isSync = false;
+        } catch (e) {
+          console.error(`WebSocket [${config.key}] message parse error`, e);
         }
       };
-      mountCallbacks.add(processOnMount);
+      ws.onclose = () => {
+        setStatuses(prev_2 => new Map(prev_2).set(config.key, 'closed'));
+        console.log(`WebSocket [${config.key}] disconnected`);
+        sockets.delete(config.key);
+      };
+    });
+    return () => {
+      sockets.forEach((ws_0, key_0) => {
+        ws_0.close();
+        sockets.delete(key_0);
+      });
+    };
+  }, [stableConfigs, websocketConfig, queryClient]);
+  const createSendMessage = useCallback(key_1 => message => {
+    const ws_1 = socketsRef.current.get(key_1);
+    if ((ws_1 === null || ws_1 === void 0 ? void 0 : ws_1.readyState) === WebSocket.OPEN) {
+      ws_1.send(JSON.stringify(message));
+    } else {
+      console.warn(`WebSocket [${key_1}] is not open`);
+    }
+  }, []);
+  const result = useMemo(() => {
+    const mapped = {};
+    stableConfigs.forEach(config_0 => {
+      var _a_0, _b_0;
+      mapped[config_0.key] = {
+        lastMessage: (_a_0 = lastMessages.get(config_0.key)) !== null && _a_0 !== void 0 ? _a_0 : null,
+        sendMessage: createSendMessage(config_0.key),
+        status: (_b_0 = statuses.get(config_0.key)) !== null && _b_0 !== void 0 ? _b_0 : 'closed'
+      };
+    });
+    return mapped;
+  }, [stableConfigs, lastMessages, statuses, createSendMessage]);
+  return result;
+};function useApi(configs, optionsOrId) {
+  const options = typeof optionsOrId === 'string' ? {
+    scopeId: optionsOrId
+  } : optionsOrId !== null && optionsOrId !== void 0 ? optionsOrId : {};
+  const {
+    scopeId = 'default',
+    persistToAtoms = true
+  } = options;
+  // Global atom setters
+  const setQueriesAtom = useSetAtom(queriesAtom);
+  const setMutationsAtom = useSetAtom(mutationsAtom);
+  // Update a single query in the global atom
+  const updateQueryAtom = useCallback((key, state) => {
+    const compositeKey = getCompositeKey(scopeId, key);
+    setQueriesAtom(prev => Object.assign(Object.assign({}, prev), {
+      [compositeKey]: state
+    }));
+  }, [setQueriesAtom, scopeId]);
+  // Update a single mutation in the global atom
+  const updateMutationAtom = useCallback((key, state) => {
+    const compositeKey = getCompositeKey(scopeId, key);
+    setMutationsAtom(prev => Object.assign(Object.assign({}, prev), {
+      [compositeKey]: state
+    }));
+  }, [setMutationsAtom, scopeId]);
+  // Enhanced query configs with atom persistence
+  const enhancedQueryConfigs = useMemo(() => {
+    const items = configs.filter(q => q.type === 'query');
+    return items.map(item => {
+      if (!item.queryConfig) return null;
+      const key = item.key;
+      const originalOnStateChange = item.queryConfig.onStateChange;
+      return Object.assign(Object.assign({}, item.queryConfig), {
+        keyToMap: key,
+        onStateChange: state => {
+          if (persistToAtoms) {
+            updateQueryAtom(key, state);
+          }
+          originalOnStateChange === null || originalOnStateChange === void 0 ? void 0 : originalOnStateChange(state);
+        },
+        options: item.queryConfig.options
+      });
+    }).filter(Boolean);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  JSON.stringify(configs), persistToAtoms, updateQueryAtom]);
+  // Enhanced mutation configs with atom persistence
+  const enhancedMutationItems = useMemo(() => {
+    const items = configs.filter(q => q.type === 'mutation' && !!q.mutationConfig);
+    return items.map(item => {
+      const key = item.key;
+      const originalOnStateChange = item.mutationConfig.onStateChange;
+      return Object.assign(Object.assign({}, item), {
+        mutationConfig: Object.assign(Object.assign({}, item.mutationConfig), {
+          onStateChange: state => {
+            if (persistToAtoms) {
+              updateMutationAtom(key, state);
+            }
+            originalOnStateChange === null || originalOnStateChange === void 0 ? void 0 : originalOnStateChange(state);
+          }
+        })
+      });
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [JSON.stringify(configs), persistToAtoms, updateMutationAtom]);
+  const webSocketItems = useMemo(() => configs.filter(q => q.type === 'websocket'),
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [JSON.stringify(configs)]);
+  // Execute hooks
+  const allQuery = useMultipleQuery(enhancedQueryConfigs);
+  const allMutation = useMultipleMutation(enhancedMutationItems);
+  const allWebSocket = useMultipleWebSocket(webSocketItems);
+  const queryKeys = enhancedQueryConfigs.map(el => el.keyToMap);
+  const mutationKeys = enhancedMutationItems.map(el => el.key);
+  const ref = useRef({
+    allQuery,
+    allMutation,
+    queryKeys,
+    mutationKeys
+  });
+  useEffect(() => {
+    ref.current = {
+      allQuery,
+      allMutation,
+      queryKeys,
+      mutationKeys
+    };
+  }, [allQuery, allMutation, queryKeys, mutationKeys]);
+  const refreshQueries = useCallback(() => {
+    ref.current.queryKeys.forEach(k => {
+      ref.current.allQuery[k].refetch();
+    });
+  }, []);
+  return {
+    allQuery,
+    allMutation,
+    allWebSocket,
+    refreshQueries
+  };
+}// ============================================================================
+// Bulk Query/Mutation Hooks
+// ============================================================================
+/**
+ * Hook to read all queries for a scope.
+ */
+function useJotaiQueries(options) {
+  const $ = c(3);
+  const {
+    scopeId
+  } = options;
+  const allQueries = useAtomValue(queriesAtom);
+  const prefix = `${scopeId}:`;
+  let scopeQueries;
+  if ($[0] !== allQueries || $[1] !== prefix) {
+    scopeQueries = {};
+    for (const [key, value] of Object.entries(allQueries)) {
+      if (key.startsWith(prefix)) {
+        scopeQueries[key.slice(prefix.length)] = value;
+      }
     }
-    (_a = storeHooks.m) == null ? void 0 : _a.call(storeHooks, atom);
+    $[0] = allQueries;
+    $[1] = prefix;
+    $[2] = scopeQueries;
+  } else {
+    scopeQueries = $[2];
   }
-  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;
+  return scopeQueries;
+}
+/**
+ * Hook to read all mutations for a scope.
+ */
+function useJotaiMutations(options) {
+  const $ = c(3);
+  const {
+    scopeId
+  } = options;
+  const allMutations = useAtomValue(mutationsAtom);
+  const prefix = `${scopeId}:`;
+  let scopeMutations;
+  if ($[0] !== allMutations || $[1] !== prefix) {
+    scopeMutations = {};
+    for (const [key, value] of Object.entries(allMutations)) {
+      if (key.startsWith(prefix)) {
+        scopeMutations[key.slice(prefix.length)] = value;
+      }
     }
+    $[0] = allMutations;
+    $[1] = prefix;
+    $[2] = scopeMutations;
+  } else {
+    scopeMutations = $[2];
   }
-  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);
+  return scopeMutations;
+}const getValueAtPath$2 = (obj, path, defaultObj) => {
+  if (!path) return undefined;
+  const normalized = path.replace(/\[(\d+)\]/g, ".$1");
+  const parts = normalized.split(".").filter(Boolean);
+  let current = obj;
+  for (let index = 0; index < parts.length; index++) {
+    const part = parts[index];
+    if (current == null) return undefined;
+    if (typeof current !== "object") return undefined;
+    const record = current;
+    // Only apply the default entry when the *root* key is missing (e.g. queryKey not found).
+    // For deeper missing paths, return undefined so callers can use the provided defaultValue.
+    if (!(part in record)) {
+      if (index === 0 && defaultObj !== undefined) {
+        current = defaultObj;
+        continue;
+      }
+      return undefined;
     }
-    (_b = storeHooks.u) == null ? void 0 : _b.call(storeHooks, atom);
-    return void 0;
+    current = record[part];
   }
-  return mounted;
+  return current;
 };
-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 useApiValues = ({
+  scopeId
+}) => {
+  const allQuery = useJotaiQueries({
+    scopeId
+  });
+  const allMutation = useJotaiMutations({
+    scopeId
+  });
+  const subscriptions = useRef(new Map());
+  const [trigger, setTrigger] = useState(0);
+  const dataRef = useRef({
+    query: allQuery,
+    mutation: allMutation
+  });
+  // Sync dataRef with latest values
+  useEffect(() => {
+    let internalTrigger = false;
+    const currentQuery = dataRef.current.query;
+    subscriptions.current.forEach((_, key) => {
+      const [type, keyPath] = key.split(":");
+      if (type === "query") {
+        const newValue = getValueAtPath$2(allQuery, keyPath);
+        const oldValue = getValueAtPath$2(currentQuery, keyPath);
+        // console.log(key, !equal(newValue, oldValue), newValue, oldValue)
+        if (!equal(newValue, oldValue)) {
+          internalTrigger = true;
+        }
+      }
+      if (type === "mutation") {
+        const newValue = getValueAtPath$2(allMutation, keyPath);
+        const oldValue = getValueAtPath$2(dataRef.current.mutation, keyPath);
+        if (!equal(newValue, oldValue)) {
+          internalTrigger = true;
+        }
+      }
+    });
+    dataRef.current = {
+      query: allQuery,
+      mutation: allMutation
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (internalTrigger) {
+      setTrigger(v => v + 1);
     }
-  }
-};
-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);
+  }, [allQuery, allMutation]);
+  // get che legge dallo store e registra le dipendenze
+  const get = useCallback((type, key, defaultValue) => {
+    var _a;
+    const keyMap = `${type}:${key}`;
+    const defaultQueries = type === "query" ? DEFAULT_QUERY_ENTRY :
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    type === "mutation" ? DEFAULT_MUTATION_ENTRY : undefined;
+    const value = (_a = getValueAtPath$2(dataRef.current[type], String(key), defaultQueries)) !== null && _a !== void 0 ? _a : defaultValue;
+    subscriptions.current.set(keyMap, value);
+    return subscriptions.current.get(keyMap);
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [trigger]);
+  return {
+    get
   };
+};new TextEncoder();
+new TextDecoder();const DefaultContainer$1 = ({
+  children
+}) => {
+  return children;
 };
-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;
+// Lazy initialization to avoid side effects at module load time
+const _formConfig = {
+  formFieldContainer: DefaultContainer$1
 };
-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;
+const {
+  useValue: useFormConfigValue} = atomStateGenerator({
+  key: 'formConfig',
+  defaultValue: _formConfig,
+  persist: false
+});/* eslint-disable @typescript-eslint/no-explicit-any */
+function useJotaiForm(formOptions) {
+  const form = useForm(formOptions);
+  return form;
+}const FormField = ({
+  config,
+  onFieldChange,
+  ns: globalNs,
+  globalErrorNs
+}) => {
+  var _a, _b;
+  const ns = (_a = config.ns) !== null && _a !== void 0 ? _a : globalNs;
+  const errorNs = (_b = config.errorNs) !== null && _b !== void 0 ? _b : globalErrorNs;
+  const {
+    formFieldContainer,
+    translateText
+  } = useFormConfigValue();
+  // TanStack Form uses field.state.meta.errors which is an array of ValidationError
+  const firstError = config.field.state.meta.errors.length > 0 ? config.field.state.meta.errors[0] : undefined;
+  const errorMessageStr = firstError ? String(firstError) : undefined;
+  const errorMessage = useMemo(() => {
+    if (!errorMessageStr) return undefined;
+    return errorNs ? translateText === null || translateText === void 0 ? void 0 : translateText(errorMessageStr, {
+      ns: errorNs || '',
+      defaultValue: ''
+    }) : errorMessageStr;
+  }, [errorMessageStr, errorNs, translateText]);
+  const label = useMemo(() => {
+    var _a_0;
+    return ns ? translateText === null || translateText === void 0 ? void 0 : translateText((_a_0 = config.label) !== null && _a_0 !== void 0 ? _a_0 : '') : config.label;
+  }, [ns, config.label, translateText]);
+  const helperMessage = useMemo(() => {
+    var _a_1;
+    return ((_a_1 = config.helper) === null || _a_1 === void 0 ? void 0 : _a_1.text) ? translateText === null || translateText === void 0 ? void 0 : translateText(config.helper.text, config.helper.translationOption) : '';
+  }, [config.helper, translateText]);
+  const ref = useRef({
+    onFieldChange,
+    handleChange: config.field.handleChange
+  });
+  useEffect(() => {
+    ref.current = {
+      onFieldChange,
+      handleChange: config.field.handleChange
+    };
+  }, [config.field.handleChange, onFieldChange]);
+  const handleChange = useCallback(value => {
+    var _a_2, _b_0;
+    // TanStack Form handleChange usually expects just the value for input
+    // but if we are manually calling it we should pass the value.
+    ref.current.handleChange(value);
+    (_b_0 = (_a_2 = ref.current).onFieldChange) === null || _b_0 === void 0 ? void 0 : _b_0.call(_a_2, value);
+  }, []);
+  const handleBlur = useCallback(() => {
+    config.field.handleBlur();
+  }, [config.field]);
+  const baseProps = useMemo(() => ({
+    value: config.field.state.value,
+    onChange: handleChange,
+    onBlur: handleBlur,
+    error: config.field.state.meta.errors.length > 0,
+    errorMessage,
+    label,
+    helperMessage
+  }), [config.field.state.value, handleChange, handleBlur, config.field.state.meta.errors.length, errorMessage, label, helperMessage]);
+  const ConfigContainer = useMemo(() => config.container, [config.container]);
+  const FormFieldContainer = useMemo(() => formFieldContainer, [formFieldContainer]);
+  if (ConfigContainer) {
+    return jsx(ConfigContainer, {
+      children: config.component(baseProps)
+    });
   }
-  if (write) {
-    config.write = write;
+  return jsx(FormFieldContainer, {
+    children: config.component(baseProps)
+  });
+};const DEFAULT_FORM_ENTRY = Object.freeze({
+  formValues: {},
+  setValue: () => {}
+});
+/**
+ * Global atom storing all form state.
+ * Key format: "scopeId:formId" or just "formId" for backward compatibility.
+ */
+const formAtom = atom({});
+const createFormSelector = formId => selectAtom(formAtom, forms => {
+  const entry = forms[formId];
+  return entry !== null && entry !== void 0 ? entry : DEFAULT_FORM_ENTRY;
+}, (a, b) => a === b || a.formValues === b.formValues && a.setValue === b.setValue);
+const useFormValue = formId => {
+  const $ = c(2);
+  let t0;
+  if ($[0] !== formId) {
+    t0 = createFormSelector(formId);
+    $[0] = formId;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
   }
-  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"
-        );
-      }
+  const selectorAtom = t0;
+  return useAtomValue(selectorAtom);
+};
+const useSetFormState = formId => {
+  const setForms = useSetAtom(formAtom);
+  return useCallback(val => {
+    setForms(prev => {
+      var _a;
+      const prevEntry = (_a = prev[formId]) !== null && _a !== void 0 ? _a : DEFAULT_FORM_ENTRY;
+      return Object.assign(Object.assign({}, prev), {
+        [formId]: Object.assign(Object.assign({}, prevEntry), val)
+      });
+    });
+  }, [formId, setForms]);
+};const getValueAtPath$1 = (obj, path, defaultObj) => {
+  if (!path) return undefined;
+  const normalized = path.replace(/\[(\d+)\]/g, '.$1');
+  const parts = normalized.split('.').filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (!current || !Object.keys(current).length) {
+      return undefined;
     }
+    if (typeof current !== 'object') return undefined;
+    current = current[part];
   }
-  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;
-      }
-    );
-  }
+  return current;
 };
-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;
+const useFormValues = ({
+  formId
+}) => {
+  // We subscribe to the specific form entry in the atoms
+  // Note: This subscription is a bit coarse (entire form entry), but we optimize re-renders locally
+  // Ideally we would want to subscribe only to specific paths, but Jotai atoms are per-form.
+  const formEntry = useFormValue(formId);
+  const currentValues = useMemo(() => formEntry.formValues, [formEntry.formValues]);
+  const subscriptions = useRef(new Map());
+  // trigger state is used to force re-render when a subscribed value changes
+  const [trigger, setTrigger] = useState(0);
+  // Ref to hold the latest values without causing re-renders itself
+  const formRef = useRef({
+    formValues: formEntry.formValues,
+    setValue: formEntry.setValue
+  });
+  useEffect(() => {
+    formRef.current.setValue = formEntry.setValue;
+  }, [formEntry.setValue]);
+  useEffect(() => {
+    let shouldTrigger = false;
+    subscriptions.current.forEach((_, path) => {
+      const newValue = getValueAtPath$1(currentValues, path);
+      const oldValue = getValueAtPath$1(formRef.current.formValues, path);
+      if (!equal(newValue, oldValue)) {
+        shouldTrigger = true;
+      }
+    });
+    formRef.current.formValues = currentValues;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (shouldTrigger) {
+      setTrigger(c => c + 1);
+    }
+  }, [currentValues]);
+  const get = useCallback((key, defaultValue) => {
+    var _a;
+    const val = (_a = getValueAtPath$1(formRef.current.formValues, key)) !== null && _a !== void 0 ? _a : defaultValue;
+    subscriptions.current.set(key, val);
+    return subscriptions.current.get(key);
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [trigger]);
+  const set = useCallback((field, value) => {
+    formRef.current.setValue(field, value);
+  }, []);
+  return {
+    get,
+    set
+  };
+};const trimObject = obj => Object.entries(obj !== null && obj !== void 0 ? obj : {}).reduce((prev, [key, val]) => Object.assign(Object.assign({}, prev), {
+  [key]: typeof val === 'string' && !['password', 'pPassword'].includes(key) ? val.trim() : val
+}), {});
+const RenderField = t0 => {
+  const $ = c(9);
+  const {
+    field,
+    fieldState,
+    fieldProps,
+    onFieldChange
+  } = t0;
+  let t1;
+  if ($[0] !== field || $[1] !== fieldProps || $[2] !== fieldState) {
+    t1 = Object.assign(Object.assign({}, fieldProps), {
+      field,
+      fieldState
+    });
+    $[0] = field;
+    $[1] = fieldProps;
+    $[2] = fieldState;
+    $[3] = t1;
   } else {
-    attachPromiseStatus(promise);
-    throw promise;
+    t1 = $[3];
   }
-});
-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);
+  const config = t1;
+  let t2;
+  if ($[4] !== config || $[5] !== fieldProps.errorNs || $[6] !== fieldProps.ns || $[7] !== onFieldChange) {
+    t2 = jsx(FormField, {
+      config,
+      ns: fieldProps.ns,
+      globalErrorNs: fieldProps.errorNs,
+      onFieldChange
     });
-    continuablePromiseMap.set(promise, continuablePromise);
+    $[4] = config;
+    $[5] = fieldProps.errorNs;
+    $[6] = fieldProps.ns;
+    $[7] = onFieldChange;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
   }
-  return continuablePromise;
+  return t2;
 };
-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);
-  }
+const DynamicFieldItem = ({
+  item,
+  form,
+  globalErrorNs,
+  formId
+}) => {
+  const {
+    get,
+    set
+  } = useFormValues({
+    formId
+  });
+  const fieldProps = useMemo(() => {
+    if (typeof item === 'function') {
+      return item({
+        get,
+        set
+      });
+    } else {
+      return item;
+    }
+  }, [get, set, item]);
+  const isHidden = useMemo(() => {
+    if (!fieldProps.hidden) {
+      return false;
+    } else if (typeof fieldProps.hidden === 'function') {
+      return fieldProps.hidden({
+        get,
+        set
+      });
+    } else {
+      return !!fieldProps.hidden;
+    }
+  }, [get, set, fieldProps]);
+  const rules = useMemo(() => {
+    if (!fieldProps.rules) {
+      return undefined;
+    } else if (typeof fieldProps.rules === 'function') {
+      return fieldProps.rules({
+        get,
+        set
+      });
+    } else {
+      return fieldProps.rules;
+    }
+  }, [get, set, fieldProps]);
+  const props = useMemo(() => {
+    var _a;
+    return Object.assign(Object.assign({}, fieldProps), {
+      errorNs: (_a = fieldProps.errorNs) !== null && _a !== void 0 ? _a : globalErrorNs
+    });
+  }, [fieldProps, globalErrorNs]);
+  if (isHidden) {
+    return jsx(Fragment, {});
+  }
+  return jsx(form.Field, {
+    name: props.name,
+    validators: rules,
+    // eslint-disable-next-line react/no-children-prop
+    children: field => jsx(RenderField, {
+      field: field,
+      fieldState: field.state,
+      fieldProps: props,
+      onFieldChange: props.onFieldChange
+    })
+  });
+};
+const SubmitItem = ({
+  item,
+  index,
+  handlersRef
+}) => {
+  const handleClick = useCallback(async () => {
+    const {
+      formControl,
+      createSubmitHandler,
+      onInvalidHandle
+    } = handlersRef.current;
+    // Partial or full validation logic
+    let isValid = true;
+    const keys = item.values;
+    if (keys && keys.length > 0) {
+      // Validate only specific fields
+      await Promise.all(keys.map(key => formControl.validateField(key, 'change')));
+      const hasError = keys.some(key_0 => {
+        // This is a simplified check. TanStack form errors might be structured differently.
+        // You might need deep checking if errors are nested objects.
+        // For now assume flat or use lodash get if possible, but state.errors is usually flat-ish map in newer versions or object.
+        // Checking standard TanStack: form.state.fieldMeta[key]?.errors
+        const meta = formControl.getFieldMeta(key_0);
+        return (meta === null || meta === void 0 ? void 0 : meta.errors) && meta.errors.length > 0;
+      });
+      isValid = !hasError;
+    } else {
+      // Validate all
+      await formControl.validateAllFields('submit');
+      isValid = formControl.state.isValid;
+    }
+    if (!isValid) {
+      onInvalidHandle(formControl.state.errors, item);
+      return;
+    }
+    const values = formControl.state.values;
+    // Call handlers
+    await createSubmitHandler(item)(values);
+  }, [item, handlersRef]);
+  const Component = useMemo(() => item.component, [item]);
+  if (item.hidden || !Component) return jsx(Fragment, {});
+  return jsx(Component, {
+    onClick: handleClick,
+    index: index,
+    type: item.type || 'button'
+  }, `submit-${index}`);
+};
+const useFormManager = ({
+  data,
+  onInvalid,
+  submit = [],
+  notification,
+  formOptions,
+  onValuesChange,
+  globalErrorNs,
+  id = 'form-manager'
+}) => {
+  const formControl = useJotaiForm(formOptions);
+  const formState = useMemo(() => formControl.state, [formControl.state]);
+  const errors = useMemo(() => formState.errors, [formState.errors]);
+  const values = useMemo(() => formState.values, [formState.values]);
+  const setFormState = useSetFormState(id);
+  const {
+    showNotification
+  } = useFormConfigValue();
+  const setValue = useCallback((field, updater) => formControl.setFieldValue(field, updater), [formControl]);
   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();
+    setFormState({
+      setValue,
+      formValues: formState.values
     });
-    rerender();
-    return unsub;
-  }, [store, atom, delay, promiseStatus]);
-  useDebugValue(value);
-  if (isPromiseLike(value)) {
-    const promise = createContinuablePromise(value, () => store.get(atom));
-    if (promiseStatus) {
-      attachPromiseStatus(promise);
+    const unsubscribe = formControl.store.subscribe(store => {
+      setFormState({
+        formValues: store.currentVal.values
+      });
+    });
+    return () => {
+      unsubscribe();
+    }; /**/
+  }, [formControl.store, setValue, formState.values, setFormState]);
+  const handleNotification = useCallback(props => {
+    if (props.message) {
+      showNotification === null || showNotification === void 0 ? void 0 : showNotification(props);
+    }
+  }, [showNotification]);
+  const filterFormData = useCallback((v, submitConfig) => {
+    const keys = submitConfig.values;
+    if (!keys || keys.length === 0) {
+      return v;
+    }
+    const out = {};
+    for (const key of keys) {
+      if (key in v) {
+        out[key] = v[key];
+      }
     }
-    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 out;
+  }, []);
+  const processSubmit = useCallback(async (d, submitConfig_0) => {
+    const filteredData = filterFormData(d, submitConfig_0);
+    if (submitConfig_0.onSuccess) {
+      return await submitConfig_0.onSuccess(filteredData);
+    }
+    throw new Error('No submit handler provided');
+  }, [filterFormData]);
+  const handleError = useCallback((error, submitConfig_1) => {
+    if (submitConfig_1.onError) {
+      submitConfig_1.onError(error);
+    }
+    const notificationProps = typeof (notification === null || notification === void 0 ? void 0 : notification.error) === 'function' ? notification.error(error.message) : notification === null || notification === void 0 ? void 0 : notification.error;
+    if (notificationProps === null || notificationProps === void 0 ? void 0 : notificationProps.message) {
+      handleNotification(notificationProps);
+    }
+  }, [handleNotification, notification]);
+  const createSubmitHandler = useCallback(submitConfig_2 => async dataSubmit => {
+    try {
+      const res = await processSubmit(trimObject(dataSubmit), submitConfig_2);
+      const notificationProps_0 = typeof (notification === null || notification === void 0 ? void 0 : notification.success) === 'function' ? notification.success(res) : notification === null || notification === void 0 ? void 0 : notification.success;
+      if (notificationProps_0 === null || notificationProps_0 === void 0 ? void 0 : notificationProps_0.message) {
+        handleNotification(notificationProps_0);
       }
-      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 */
+      return res;
+    } catch (error_0) {
+      handleError(error_0, submitConfig_2);
+      throw error_0;
+    }
+  }, [processSubmit, notification, handleNotification, handleError]);
+  const onInvalidHandle = useCallback((err, submitConfig_3) => {
+    onInvalid === null || onInvalid === void 0 ? void 0 : onInvalid(err);
+    handleError(new Error('invalidData'), submitConfig_3);
+  }, [handleError, onInvalid]);
+  const handlersRef = useRef({
+    formControl,
+    onInvalidHandle,
+    createSubmitHandler,
+    setValue: formControl.setFieldValue,
+    trigger: formControl.validateField,
+    onValuesChange
+  });
+  useEffect(() => {
+    handlersRef.current.onInvalidHandle = onInvalidHandle;
+    handlersRef.current.createSubmitHandler = createSubmitHandler;
+    handlersRef.current.setValue = formControl.setFieldValue;
+    handlersRef.current.trigger = formControl.validateField;
+    handlersRef.current.onValuesChange = onValuesChange;
+  }, [onInvalidHandle, createSubmitHandler, formControl, onValuesChange]);
+  const fields = useMemo(() => data.map((item, index) => {
+    var _a, _b;
+    const staticItem = typeof item === 'function' ? null : item;
+    return {
+      index: (_a = staticItem === null || staticItem === void 0 ? void 0 : staticItem.index) !== null && _a !== void 0 ? _a : index,
+      element: jsx(DynamicFieldItem, {
+        item: item,
+        form: formControl,
+        globalErrorNs: globalErrorNs,
+        formId: id
+      }, (_b = staticItem === null || staticItem === void 0 ? void 0 : staticItem.name) !== null && _b !== void 0 ? _b : index),
+      renderInFooter: !!(staticItem === null || staticItem === void 0 ? void 0 : staticItem.renderInFooter),
+      renderInHeader: !!(staticItem === null || staticItem === void 0 ? void 0 : staticItem.renderInHeader)
+    };
+  }), [data, formControl, globalErrorNs, id]);
+  const submits = useMemo(() => submit.map((submitConfig_4, index_0) => {
+    return {
+      index: submitConfig_4.index === undefined ? index_0 : submitConfig_4.index,
+      element: jsx(SubmitItem, {
+        item: submitConfig_4,
+        index: index_0,
+        handlersRef: handlersRef
+      }, `submit-${index_0}`),
+      renderInFooter: !!submitConfig_4.renderInFooter,
+      renderInHeader: !!submitConfig_4.renderInHeader,
+      isSubmit: true
+    };
+  }), [submit]);
+  const elements = useMemo(() => fields.concat(submits), [fields, submits]);
+  const formContents = useMemo(() => [...data, ...submit], [data, submit]);
+  useEffect(() => {
+    var _a_0, _b_0;
+    (_b_0 = (_a_0 = handlersRef.current).onValuesChange) === null || _b_0 === void 0 ? void 0 : _b_0.call(_a_0, values, handlersRef.current.setValue);
+  }, [values]);
+  return {
+    elements,
+    formContents,
+    errors,
+    formValues: values,
+    setValue
+  };
+};/* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * Optimized shallow equality check for objects and functions
  * @param objA - First object to compare
@@ -982,61 +1737,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.
@@ -2377,850 +3077,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,