@gaddario98/react-core 2.0.9 → 2.1.0

package/dist/pages/index.js

@@ -1,4 +1,4 @@
-'use strict';var jsxRuntime=require('react/jsx-runtime'),React=require('react'),jotai=require('jotai'),utils=require('jotai/utils'),fflate=require('fflate'),compilerRuntime=require('react/compiler-runtime'),reactQuery=require('@tanstack/react-query'),axios=require('axios'),equal=require('fast-deep-equal'),jotaiFamily=require('jotai-family'),reactForm=require('@tanstack/react-form');/******************************************************************************
+'use strict';var jsxRuntime=require('react/jsx-runtime'),react=require('react'),reactQueries=require('@gaddario98/react-queries'),jotai=require('jotai'),compilerRuntime=require('react/compiler-runtime'),reactState=require('@gaddario98/react-state'),equal=require('fast-deep-equal'),reactForm=require('@gaddario98/react-form'),jotaiFamily=require('jotai-family'),reactQuery=require('@tanstack/react-query');/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -25,1593 +25,6 @@ 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;
-};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 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 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 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 = fflate.strToU8(value);
-        const compressed = fflate.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();
-  };
-  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();
-      });
-    }
-    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 = fflate.inflateSync(bytes);
-          return fflate.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;
-      }
-    },
-    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);
-      }
-    },
-    removeItem: key => {
-      try {
-        pendingWrites.delete(key);
-        base.removeItem(key);
-      } catch (error) {
-        console.error('Error removing item:', error);
-      }
-    }
-  };
-};
-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);
-  }
-};
-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 ? utils.atomWithStorage(key, defaultValue, utils.createJSONStorage(() => resolvedStorage)) : jotai.atom(defaultValue);
-  const useValue = () => {
-    const [value] = jotai.useAtom(jotaiAtom);
-    return value;
-  };
-  const useState = () => {
-    const $ = compilerRuntime.c(3);
-    const [value, setValue] = jotai.useAtom(jotaiAtom);
-    let t0;
-    if ($[0] !== setValue || $[1] !== value) {
-      t0 = [value, setValue];
-      $[0] = setValue;
-      $[1] = value;
-      $[2] = t0;
-    } else {
-      t0 = $[2];
-    }
-    return t0;
-  };
-  const useReset = () => {
-    const $ = compilerRuntime.c(2);
-    const [, setValue] = jotai.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 = utils.atomWithStorage('queries-atom', {}, utils.createJSONStorage(() => storage), {
-  getOnInit: true
-});
-/**
- * Global atom storing all mutation results.
- * Key format: "scopeId:mutationKey"
- */
-const mutationsAtom = jotai.atom({});
-// ============================================================================
-// Helper to generate composite keys
-// ============================================================================
-const getCompositeKey = (scopeId, key) => `${scopeId}:${key}`;const apiClient = axios.create({
-  timeout: 30000,
-  headers: {
-    'Content-Type': 'application/json'
-  }
-});
-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');
-  }
-});
-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;
-      }
-    }
-    // 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.
-        }
-      }
-    }
-    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;
-    }
-    throw new Error(`Request failed with status ${response.status}`);
-  } catch (error) {
-    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 defaultQueryClient = new reactQuery.QueryClient({
-  defaultOptions: {
-    queries: {
-      retry: 2
-      //  staleTime: 2 * 60 * 1000,
-    }
-  }
-});
-const {
-  useValue: useApiConfigValue} = atomStateGenerator({
-  key: 'apiConfig',
-  defaultValue: {
-    endpoints: _endpoints,
-    requestFn: apiRequest,
-    queryClient: defaultQueryClient
-  },
-  persist: false
-});const useMultipleQuery = t0 => {
-  const $ = compilerRuntime.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 = React.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];
-  }
-  React.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
-        }
-      });
-      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 = reactQuery.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 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);
-          }
-        }
-        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];
-  }
-  React.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] = React.useReducer(mutationReducer, configs, initMutationStates);
-  // Accessor for current state
-  const getState = React.useCallback(key => {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    return reducerStates[key] || defaultState;
-  }, [reducerStates]);
-  // Dispatcher that handles both modes
-  const dispatch = React.useCallback(action => {
-    dispatchReducer(action);
-  }, []);
-  const executeMutation = React.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 {
-        result = await requestFn({
-          url: fullEndpoint,
-          method,
-          body: data,
-          headers: mergedHeaders,
-          converter
-        });
-      }
-      dispatch({
-        type: "SUCCESS",
-        key: key_0,
-        data: result
-      });
-      // Invalidate queries
-      if (queryKeyToInvalidate) {
-        queryKeyToInvalidate.forEach(qKey => {
-          queryClient.invalidateQueries({
-            queryKey: [qKey],
-            exact: false
-          });
-        });
-      }
-      // 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));
-      }
-      // 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));
-      }
-      // 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 = React.useRef({
-    dispatch,
-    executeMutation
-  });
-  React.useEffect(() => {
-    ref.current = {
-      dispatch,
-      executeMutation
-    };
-  }, [dispatch, executeMutation]);
-  const allMutation = React.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 = React.useRef(new Map());
-  const [statuses, setStatuses] = React.useState(new Map());
-  const [lastMessages, setLastMessages] = React.useState(new Map());
-  // Stabilize configs reference
-  const stableConfigs = React.useMemo(() => configs, [configs]);
-  React.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 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
-              });
-            });
-          }
-        } catch (e) {
-          console.error(`WebSocket [${config.key}] message parse error`, e);
-        }
-      };
-      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 = React.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 = React.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 = jotai.useSetAtom(queriesAtom);
-  const setMutationsAtom = jotai.useSetAtom(mutationsAtom);
-  // Update a single query in the global atom
-  const updateQueryAtom = React.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 = React.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 = React.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 = React.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 = React.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 = React.useRef({
-    allQuery,
-    allMutation,
-    queryKeys,
-    mutationKeys
-  });
-  React.useEffect(() => {
-    ref.current = {
-      allQuery,
-      allMutation,
-      queryKeys,
-      mutationKeys
-    };
-  }, [allQuery, allMutation, queryKeys, mutationKeys]);
-  const refreshQueries = React.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 $ = compilerRuntime.c(3);
-  const {
-    scopeId
-  } = options;
-  const allQueries = jotai.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;
-      }
-    }
-    $[0] = allQueries;
-    $[1] = prefix;
-    $[2] = scopeQueries;
-  } else {
-    scopeQueries = $[2];
-  }
-  return scopeQueries;
-}
-/**
- * Hook to read all mutations for a scope.
- */
-function useJotaiMutations(options) {
-  const $ = compilerRuntime.c(3);
-  const {
-    scopeId
-  } = options;
-  const allMutations = jotai.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];
-  }
-  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;
-    }
-    current = record[part];
-  }
-  return current;
-};
-const useApiValues = ({
-  scopeId
-}) => {
-  const allQuery = useJotaiQueries({
-    scopeId
-  });
-  const allMutation = useJotaiMutations({
-    scopeId
-  });
-  const subscriptions = React.useRef(new Map());
-  const [trigger, setTrigger] = React.useState(0);
-  const dataRef = React.useRef({
-    query: allQuery,
-    mutation: allMutation
-  });
-  // Sync dataRef with latest values
-  React.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);
-    }
-  }, [allQuery, allMutation]);
-  // get che legge dallo store e registra le dipendenze
-  const get = React.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;
-};
-// Lazy initialization to avoid side effects at module load time
-const _formConfig = {
-  formFieldContainer: DefaultContainer$1
-};
-const {
-  useValue: useFormConfigValue} = atomStateGenerator({
-  key: 'formConfig',
-  defaultValue: _formConfig,
-  persist: false
-});/* eslint-disable @typescript-eslint/no-explicit-any */
-function useJotaiForm(formOptions) {
-  const form = reactForm.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 = React.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 = React.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 = React.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 = React.useRef({
-    onFieldChange,
-    handleChange: config.field.handleChange
-  });
-  React.useEffect(() => {
-    ref.current = {
-      onFieldChange,
-      handleChange: config.field.handleChange
-    };
-  }, [config.field.handleChange, onFieldChange]);
-  const handleChange = React.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 = React.useCallback(() => {
-    config.field.handleBlur();
-  }, [config.field]);
-  const baseProps = React.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 = React.useMemo(() => config.container, [config.container]);
-  const FormFieldContainer = React.useMemo(() => formFieldContainer, [formFieldContainer]);
-  if (ConfigContainer) {
-    return jsxRuntime.jsx(ConfigContainer, {
-      children: config.component(baseProps)
-    });
-  }
-  return jsxRuntime.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 = jotai.atom({});
-const createFormSelector = formId => utils.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 $ = compilerRuntime.c(2);
-  let t0;
-  if ($[0] !== formId) {
-    t0 = createFormSelector(formId);
-    $[0] = formId;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  const selectorAtom = t0;
-  return jotai.useAtomValue(selectorAtom);
-};
-const useSetFormState = formId => {
-  const setForms = jotai.useSetAtom(formAtom);
-  return React.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 current;
-};
-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 = React.useMemo(() => formEntry.formValues, [formEntry.formValues]);
-  const subscriptions = React.useRef(new Map());
-  // trigger state is used to force re-render when a subscribed value changes
-  const [trigger, setTrigger] = React.useState(0);
-  // Ref to hold the latest values without causing re-renders itself
-  const formRef = React.useRef({
-    formValues: formEntry.formValues,
-    setValue: formEntry.setValue
-  });
-  React.useEffect(() => {
-    formRef.current.setValue = formEntry.setValue;
-  }, [formEntry.setValue]);
-  React.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 = React.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 = React.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 $ = compilerRuntime.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 {
-    t1 = $[3];
-  }
-  const config = t1;
-  let t2;
-  if ($[4] !== config || $[5] !== fieldProps.errorNs || $[6] !== fieldProps.ns || $[7] !== onFieldChange) {
-    t2 = jsxRuntime.jsx(FormField, {
-      config,
-      ns: fieldProps.ns,
-      globalErrorNs: fieldProps.errorNs,
-      onFieldChange
-    });
-    $[4] = config;
-    $[5] = fieldProps.errorNs;
-    $[6] = fieldProps.ns;
-    $[7] = onFieldChange;
-    $[8] = t2;
-  } else {
-    t2 = $[8];
-  }
-  return t2;
-};
-const DynamicFieldItem = ({
-  item,
-  form,
-  globalErrorNs,
-  formId
-}) => {
-  const {
-    get,
-    set
-  } = useFormValues({
-    formId
-  });
-  const fieldProps = React.useMemo(() => {
-    if (typeof item === 'function') {
-      return item({
-        get,
-        set
-      });
-    } else {
-      return item;
-    }
-  }, [get, set, item]);
-  const isHidden = React.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 = React.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 = React.useMemo(() => {
-    var _a;
-    return Object.assign(Object.assign({}, fieldProps), {
-      errorNs: (_a = fieldProps.errorNs) !== null && _a !== void 0 ? _a : globalErrorNs
-    });
-  }, [fieldProps, globalErrorNs]);
-  if (isHidden) {
-    return jsxRuntime.jsx(jsxRuntime.Fragment, {});
-  }
-  return jsxRuntime.jsx(form.Field, {
-    name: props.name,
-    validators: rules,
-    // eslint-disable-next-line react/no-children-prop
-    children: field => jsxRuntime.jsx(RenderField, {
-      field: field,
-      fieldState: field.state,
-      fieldProps: props,
-      onFieldChange: props.onFieldChange
-    })
-  });
-};
-const SubmitItem = ({
-  item,
-  index,
-  handlersRef
-}) => {
-  const handleClick = React.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 = React.useMemo(() => item.component, [item]);
-  if (item.hidden || !Component) return jsxRuntime.jsx(jsxRuntime.Fragment, {});
-  return jsxRuntime.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 = React.useMemo(() => formControl.state, [formControl.state]);
-  const errors = React.useMemo(() => formState.errors, [formState.errors]);
-  const values = React.useMemo(() => formState.values, [formState.values]);
-  const setFormState = useSetFormState(id);
-  const {
-    showNotification
-  } = useFormConfigValue();
-  const setValue = React.useCallback((field, updater) => formControl.setFieldValue(field, updater), [formControl]);
-  React.useEffect(() => {
-    setFormState({
-      setValue,
-      formValues: formState.values
-    });
-    const unsubscribe = formControl.store.subscribe(store => {
-      setFormState({
-        formValues: store.currentVal.values
-      });
-    });
-    return () => {
-      unsubscribe();
-    }; /**/
-  }, [formControl.store, setValue, formState.values, setFormState]);
-  const handleNotification = React.useCallback(props => {
-    if (props.message) {
-      showNotification === null || showNotification === void 0 ? void 0 : showNotification(props);
-    }
-  }, [showNotification]);
-  const filterFormData = React.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 out;
-  }, []);
-  const processSubmit = React.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 = React.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 = React.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 res;
-    } catch (error_0) {
-      handleError(error_0, submitConfig_2);
-      throw error_0;
-    }
-  }, [processSubmit, notification, handleNotification, handleError]);
-  const onInvalidHandle = React.useCallback((err, submitConfig_3) => {
-    onInvalid === null || onInvalid === void 0 ? void 0 : onInvalid(err);
-    handleError(new Error('invalidData'), submitConfig_3);
-  }, [handleError, onInvalid]);
-  const handlersRef = React.useRef({
-    formControl,
-    onInvalidHandle,
-    createSubmitHandler,
-    setValue: formControl.setFieldValue,
-    trigger: formControl.validateField,
-    onValuesChange
-  });
-  React.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 = React.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: jsxRuntime.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 = React.useMemo(() => submit.map((submitConfig_4, index_0) => {
-    return {
-      index: submitConfig_4.index === undefined ? index_0 : submitConfig_4.index,
-      element: jsxRuntime.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 = React.useMemo(() => fields.concat(submits), [fields, submits]);
-  const formContents = React.useMemo(() => [...data, ...submit], [data, submit]);
-  React.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
@@ -1793,30 +206,30 @@ const usePageValues = ({
 }) => {
   const {
     get: getApiValues
-  } = useApiValues({
+  } = reactQueries.useApiValues({
     scopeId: pageId
   });
   const {
     get: getFormValues,
     set: setFormValues
-  } = useFormValues({
+  } = reactForm.useFormValues({
     formId: pageId
   });
-  const subscriptions = React.useRef(new Map());
-  const [trigger, setTrigger] = React.useState(0);
+  const subscriptions = react.useRef(new Map());
+  const [trigger, setTrigger] = react.useState(0);
   const [pageVariables, setPageVariables] = jotai.useAtom(pageVariablesAtomFamily(pageId));
-  const initialized = React.useRef(false);
-  React.useEffect(() => {
+  const initialized = react.useRef(false);
+  react.useEffect(() => {
     if (!initialized.current && initialValues) {
       setPageVariables(initialValues);
       initialized.current = true;
     }
   }, [initialValues, setPageVariables]);
-  const dataRef = React.useRef({
+  const dataRef = react.useRef({
     state: pageVariables
   });
   // Sync dataRef with latest values
-  React.useEffect(() => {
+  react.useEffect(() => {
     let internalTrigger = false;
     subscriptions.current.forEach((_, key) => {
       const [type, keyPath] = key.split(':');
@@ -1835,7 +248,7 @@ const usePageValues = ({
     }
   }, [pageVariables]);
   // get che legge dallo store e registra le dipendenze
-  const get = React.useCallback((type, key, defaultValue) => {
+  const get = react.useCallback((type, key, defaultValue) => {
     var _a;
     const keyMap = `${type}:${key}`;
     switch (type) {
@@ -1869,7 +282,7 @@ const usePageValues = ({
   // eslint-disable-next-line react-hooks/exhaustive-deps
   [pageId, trigger, getApiValues, getFormValues]);
   // set stabile
-  const set = React.useCallback(type => {
+  const set = react.useCallback(type => {
     if (type === 'form') {
       return setFormValues;
     }
@@ -1899,7 +312,7 @@ const PageContentItemInner = ({
   } = usePageValues({
     pageId
   });
-  const isHidden = React.useMemo(() => {
+  const isHidden = react.useMemo(() => {
     if (typeof item.hidden === 'function') {
       return item.hidden({
         get,
@@ -1915,7 +328,7 @@ const PageContentItemInner = ({
     pageId: pageId
   }, (_a = item.key) !== null && _a !== void 0 ? _a : '');
 };
-const PageContentItem = React.memo(PageContentItemInner);
+const PageContentItem = react.memo(PageContentItemInner);
 const useGenerateContentRender = ({
   pageId,
   ns = '',
@@ -1928,7 +341,7 @@ const useGenerateContentRender = ({
   } = usePageValues({
     pageId
   });
-  const contentsWithQueriesDeps = React.useMemo(() => {
+  const contentsWithQueriesDeps = react.useMemo(() => {
     if (typeof contents === 'function') {
       return contents({
         get,
@@ -1938,14 +351,14 @@ const useGenerateContentRender = ({
     return Array.isArray(contents) ? contents : [];
   }, [contents, get, set]);
   // Memoize form elements separately - only recalculate when formData.elements changes
-  const formElementsWithKey = React.useMemo(() => {
+  const formElementsWithKey = react.useMemo(() => {
     if (!Array.isArray(formData.elements)) return [];
     return formData.elements.map((el, idx) => Object.assign(Object.assign({}, el), {
       key: `form-element-${el.index || idx}`
     }));
   }, [formData.elements]);
   // Memoize dynamic elements - only recalculate when contents change
-  const dynamicElements = React.useMemo(() => contentsWithQueriesDeps.map((content, index) => {
+  const dynamicElements = react.useMemo(() => contentsWithQueriesDeps.map((content, index) => {
     var _a;
     const stableKey = getStableKey(content, index);
     return {
@@ -1961,7 +374,7 @@ const useGenerateContentRender = ({
     };
   }), [contentsWithQueriesDeps, ns, pageId]);
   // Merge and sort - only when either array changes
-  const memorizedContents = React.useMemo(() => [...dynamicElements, ...formElementsWithKey].sort((a, b) => a.index - b.index || String(a.key).localeCompare(String(b.key))), [dynamicElements, formElementsWithKey]);
+  const memorizedContents = react.useMemo(() => [...dynamicElements, ...formElementsWithKey].sort((a, b) => a.index - b.index || String(a.key).localeCompare(String(b.key))), [dynamicElements, formElementsWithKey]);
   return {
     components: memorizedContents,
     allContents: [...contentsWithQueriesDeps, ...formData.formContents]
@@ -2770,7 +1183,7 @@ function resolveMetadata(meta, ctx) {
     resolved.customMeta = customMeta;
   }
   return resolved;
-}const MetadataStoreContext = React.createContext(null);
+}const MetadataStoreContext = react.createContext(null);
 /**
  * Provides a request-scoped MetadataStore via React Context.
  *
@@ -2824,7 +1237,7 @@ function MetadataStoreProvider(t0) {
  * Returns `null` if no provider is found (falls back to global store in consumers).
  */
 function useMetadataStore() {
-  return React.useContext(MetadataStoreContext);
+  return react.useContext(MetadataStoreContext);
 }/**
  * Optional dev-only metadata logging.
  *
@@ -2887,9 +1300,9 @@ let _pageConfig = {
   HeaderContainer: DefaultContainer,
   FooterContainer: DefaultContainer,
   BodyContainer: DefaultContainer,
-  authPageImage: '',
+  authPageImage: "",
   authPageProps: {
-    id: 'auth-page'
+    id: "auth-page"
   },
   isLogged: val => !!(val === null || val === void 0 ? void 0 : val.id) && !!val.isLogged,
   ItemsContainer: ({
@@ -2899,8 +1312,8 @@ let _pageConfig = {
     children
   }) => children,
   meta: {
-    title: '',
-    description: ''
+    title: "",
+    description: ""
   },
   // Metadata configuration
   defaultMetadata: {},
@@ -2913,7 +1326,7 @@ let _pageConfig = {
     preloadOnHover: false,
     preloadOnFocus: false,
     timeout: 30000,
-    logMetrics: process.env.NODE_ENV === 'development'
+    logMetrics: process.env.NODE_ENV === "development"
   }
 };
 /**
@@ -2925,9 +1338,9 @@ function initializePageConfig() {
     HeaderContainer: DefaultContainer,
     FooterContainer: DefaultContainer,
     BodyContainer: DefaultContainer,
-    authPageImage: '',
+    authPageImage: "",
     authPageProps: {
-      id: 'auth-page'
+      id: "auth-page"
     },
     isLogged: val => !!(val === null || val === void 0 ? void 0 : val.id) && !!val.isLogged,
     ItemsContainer: ({
@@ -2937,8 +1350,8 @@ function initializePageConfig() {
       children
     }) => children,
     meta: {
-      title: '',
-      description: ''
+      title: "",
+      description: ""
     },
     // Metadata configuration
     defaultMetadata: {},
@@ -2951,7 +1364,7 @@ function initializePageConfig() {
       preloadOnHover: false,
       preloadOnFocus: false,
       timeout: 30000,
-      logMetrics: process.env.NODE_ENV === 'development'
+      logMetrics: process.env.NODE_ENV === "development"
     }
   };
   return _pageConfig;
@@ -2965,8 +1378,8 @@ const {
   useValue: usePageConfigValue,
   useState: usePageConfigState,
   useReset: usePageConfigReset
-} = atomStateGenerator({
-  key: 'pageConfig',
+} = reactState.atomStateGenerator({
+  key: "pageConfig",
   defaultValue: _pageConfig,
   persist: false
 });/**
@@ -3029,7 +1442,7 @@ function useFormData({
   } = usePageValues({
     pageId
   });
-  const hiddenMapped = React.useCallback(() => {
+  const hiddenMapped = react.useCallback(() => {
     const isHidden = form === null || form === void 0 ? void 0 : form.hidden;
     if (!isHidden) return false;
     if (typeof isHidden === 'function') {
@@ -3041,7 +1454,7 @@ function useFormData({
       return !!isHidden;
     }
   }, [form === null || form === void 0 ? void 0 : form.hidden, get, set]);
-  const mappedFormData = React.useMemo(() => {
+  const mappedFormData = react.useMemo(() => {
     if (!(form === null || form === void 0 ? void 0 : form.data) || hiddenMapped()) return [];
     return form.data.map(el => {
       if (typeof el === 'function') {
@@ -3060,7 +1473,7 @@ function useFormData({
       });
     });
   }, [form, get, hiddenMapped, set]);
-  const formSubmit = React.useMemo(() => {
+  const formSubmit = react.useMemo(() => {
     if (!(form === null || form === void 0 ? void 0 : form.submit) || hiddenMapped()) return [];
     const submitFn = form.submit;
     return (typeof submitFn === 'function' ? submitFn({
@@ -3085,9 +1498,9 @@ function useFormData({
   var _a_0;
   const {
     queryClient
-  } = useApiConfigValue();
-  const [defaultValueQuery, setDefaultValueQuery] = React.useState(form === null || form === void 0 ? void 0 : form.defaultValues);
-  React.useEffect(() => {
+  } = reactQueries.useApiConfigValue();
+  const [defaultValueQuery, setDefaultValueQuery] = react.useState(form === null || form === void 0 ? void 0 : form.defaultValues);
+  react.useEffect(() => {
     if (!(form === null || form === void 0 ? void 0 : form.defaultValueQueryKey)) {
       // setDefaultValueQuery(form?.defaultValues)
       return;
@@ -3106,7 +1519,7 @@ function useFormData({
     });
     return () => unsubscribe();
   }, [form === null || form === void 0 ? void 0 : form.defaultValueQueryKey, form === null || form === void 0 ? void 0 : form.defaultValues, queryClient]);
-  const defaultValues = React.useMemo(() => {
+  const defaultValues = react.useMemo(() => {
     var _a, _b;
     return Object.assign(Object.assign({}, defaultValueQuery !== null && defaultValueQuery !== void 0 ? defaultValueQuery : {}), (_b = (_a = form === null || form === void 0 ? void 0 : form.defaultValueQueryMap) === null || _a === void 0 ? void 0 : _a.call(form, defaultValueQuery)) !== null && _b !== void 0 ? _b : {});
   }, [defaultValueQuery, form]);
@@ -3118,7 +1531,7 @@ function useFormData({
     pageId
   });
   // Call useFormManager hook at top level (maintains hook order)
-  const rawFormData = useFormManager(Object.assign(Object.assign({}, form), {
+  const rawFormData = reactForm.useFormManager(Object.assign(Object.assign({}, form), {
     data: mappedFormData,
     ns,
     submit: formSubmit,
@@ -3129,7 +1542,7 @@ function useFormData({
       formId: pageId
     })
   }));
-  const formData = React.useMemo(() => Object.assign(Object.assign({}, rawFormData), {
+  const formData = react.useMemo(() => Object.assign(Object.assign({}, rawFormData), {
     formContents: rawFormData.formContents
   }), [rawFormData]);
   return {
@@ -3244,7 +1657,7 @@ const usePageConfig = t0 => {
   } else {
     t7 = $[17];
   }
-  useApi(processedQueries, t7);
+  reactQueries.useApi(processedQueries, t7);
   let t8;
   if ($[18] !== pageId || $[19] !== viewSettings) {
     t8 = {
@@ -3300,7 +1713,7 @@ function useMetadata({
     translateText,
     locale
   } = usePageConfigValue();
-  const t = React.useMemo(() => translateText !== null && translateText !== void 0 ? translateText : key => key, [translateText]);
+  const t = react.useMemo(() => translateText !== null && translateText !== void 0 ? translateText : key => key, [translateText]);
   const {
     get,
     set
@@ -3309,7 +1722,7 @@ function useMetadata({
   });
   const metadataStore = useMetadataStore();
   // Step 1: Evaluate metadata (if function)
-  const evaluatedMeta = React.useMemo(() => {
+  const evaluatedMeta = react.useMemo(() => {
     if (!meta) return {};
     if (typeof meta === 'function') {
       return meta({
@@ -3320,12 +1733,12 @@ function useMetadata({
     return meta;
   }, [meta, get, set]);
   // Step 2: Resolve all dynamic evaluator functions into plain values
-  const resolved = React.useMemo(() => resolveMetadata(evaluatedMeta, {
+  const resolved = react.useMemo(() => resolveMetadata(evaluatedMeta, {
     get,
     set
   }), [evaluatedMeta, get, set]);
   // Step 3: Translate metadata strings (i18n)
-  const translated = React.useMemo(() => {
+  const translated = react.useMemo(() => {
     var _a;
     const result = Object.assign({}, resolved);
     // Translate basic fields
@@ -3396,7 +1809,7 @@ function useMetadata({
     return result;
   }, [resolved, t, locale]);
   // Step 4: Apply metadata
-  React.useEffect(() => {
+  react.useEffect(() => {
     if (!autoApply) return;
     // If we have a request-scoped store (SSR), write to it
     if (metadataStore) {
@@ -3493,8 +1906,8 @@ const MetadataManager = MetadataManagerImpl;const PageGenerator = _a => {
     authValues,
     authPageProps
   } = usePageConfigValue();
-  const isUnlogged = React.useMemo(() => enableAuthControl && !isLogged(authValues ? authValues : null), [enableAuthControl, authValues, isLogged]);
-  const selectedProps = React.useMemo(() => {
+  const isUnlogged = react.useMemo(() => enableAuthControl && !isLogged(authValues ? authValues : null), [enableAuthControl, authValues, isLogged]);
+  const selectedProps = react.useMemo(() => {
     return enableAuthControl && isUnlogged ? authPageProps : props;
   }, [enableAuthControl, isUnlogged, authPageProps, props]);
   const {
@@ -3504,7 +1917,7 @@ const MetadataManager = MetadataManagerImpl;const PageGenerator = _a => {
     id = 'default-page-id',
     viewSettings,
     ns
-  } = React.useMemo(() => selectedProps, [selectedProps]);
+  } = react.useMemo(() => selectedProps, [selectedProps]);
   const config = usePageConfig({
     queries,
     form,
@@ -3527,26 +1940,26 @@ const MetadataManager = MetadataManagerImpl;const PageGenerator = _a => {
     ns,
     pageConfig: config
   });
-  const LayoutComponent = React.useMemo(() => {
+  const LayoutComponent = react.useMemo(() => {
     var _a_0;
     return (_a_0 = mappedViewSettings.layoutComponent) !== null && _a_0 !== void 0 ? _a_0 : BodyContainer;
   }, [mappedViewSettings.layoutComponent, BodyContainer]);
-  const layoutProps = React.useMemo(() => {
+  const layoutProps = react.useMemo(() => {
     var _a_1;
     return (_a_1 = mappedViewSettings.layoutProps) !== null && _a_1 !== void 0 ? _a_1 : {};
   }, [mappedViewSettings.layoutProps]);
-  const PageContainerComponent = React.useMemo(() => {
+  const PageContainerComponent = react.useMemo(() => {
     var _a_2;
     return (_a_2 = mappedViewSettings.pageContainerComponent) !== null && _a_2 !== void 0 ? _a_2 : PageContainer;
   }, [mappedViewSettings.pageContainerComponent, PageContainer]);
-  const pageContainerProps = React.useMemo(() => {
+  const pageContainerProps = react.useMemo(() => {
     var _a_3;
     return (_a_3 = mappedViewSettings.pageContainerProps) !== null && _a_3 !== void 0 ? _a_3 : {};
   }, [mappedViewSettings.pageContainerProps]);
-  const layoutBody = React.useMemo(() => body, [body]);
+  const layoutBody = react.useMemo(() => body, [body]);
   const store = jotai.useStore();
-  const refreshQueries = React.useCallback(() => {
-    const val = store.get(queriesAtom);
+  const refreshQueries = react.useCallback(() => {
+    const val = store.get(reactQueries.queriesAtom);
     Object.values(val).forEach(query => {
       query.refetch();
     });
@@ -3658,7 +2071,7 @@ const MetadataManager = MetadataManagerImpl;const PageGenerator = _a => {
   return t4;
 };
 // Export with React.memo and fast-deep-equal comparator for optimal performance
-const Container = React.memo(ContainerImpl, (prevProps, nextProps) => {
+const Container = react.memo(ContainerImpl, (prevProps, nextProps) => {
   // Return true if props are equal (component should NOT re-render)
   return deepEqual(prevProps, nextProps);
 });
@@ -3718,7 +2131,7 @@ const RenderComponentImpl = ({
   }
 };
 // Export with React.memo and fast-deep-equal comparator for optimal performance
-const RenderComponent = React.memo(RenderComponentImpl, (prevProps, nextProps) => {
+const RenderComponent = react.memo(RenderComponentImpl, (prevProps, nextProps) => {
   // Return true if props are equal (component should NOT re-render)
   return deepEqual(prevProps, nextProps);
 });const RenderComponents = props => {