fastapi-rtk 1.0.49 → 1.0.51

package/dist/core/esm/Wrappers/ApiProvider/hooks/useProvideApi.mjs

@@ -1,8 +1,9 @@
-import { useState, useRef, useEffect, useMemo, useCallback } from "react";
+import { useState, useRef, useMemo, useCallback, useEffect } from "react";
 import { convertId, getItemId, urlJoin } from "fastapi-rtk/utils";
-import { useDidUpdate, useSetState } from "@mantine/hooks";
-import { keepPreviousData } from "../../../../../.external/esm/@tanstack_query-core@5.90.20/@tanstack/query-core/build/modern/utils.mjs";
-import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.90.21_react@19.2.4/@tanstack/react-query/build/modern/useQuery.mjs";
+import { useDidUpdate } from "@mantine/hooks";
+import { keepPreviousData } from "../../../../../.external/esm/@tanstack_query-core@5.91.2/@tanstack/query-core/build/modern/utils.mjs";
+import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.91.3_react@19.2.4/@tanstack/react-query/build/modern/useQuery.mjs";
+import { useInfiniteQuery } from "../../../../../.external/esm/@tanstack_react-query@5.91.3_react@19.2.4/@tanstack/react-query/build/modern/useInfiniteQuery.mjs";
 import { useLang } from "../../../hooks/lang/useLang.mjs";
 import { createItem } from "../utils/api/createItem.mjs";
 import { deleteItem } from "../utils/api/deleteItem.mjs";
@@ -16,6 +17,9 @@ import { updateItem } from "../utils/api/updateItem.mjs";
 import { uploadItems } from "../utils/api/uploadItems.mjs";
 import { convertInfo } from "../utils/convertInfo.mjs";
 import { createQueryParams } from "../utils/createQueryParams.mjs";
+import { useApiActions } from "./utils/useApiActions.mjs";
+import { useLatest } from "./utils/useLatest.mjs";
+import { useStreamingData } from "./utils/useStreamingData.mjs";
 const defaultApi = {
   getItem,
   getItems,
@@ -28,6 +32,15 @@ const defaultApi = {
   formCreateItem,
   formUpdateItem
 };
+const getStreamingQuerySignature = (params) => {
+  if (!params) {
+    return null;
+  }
+  const rest = { ...params };
+  delete rest.page;
+  delete rest.streaming;
+  return JSON.stringify(rest);
+};
 function useProvideApi({
   path,
   initialQueryParams,
@@ -40,16 +53,15 @@ function useProvideApi({
   resetQueryParamsOnPathChange = true,
   infoQueryProps,
   dataQueryProps,
+  streamingQueryProps,
   throwOnError = false,
   streaming: streamingMode = false
 }, api = defaultApi) {
+  var _a;
   const [queryParams, setQueryParams] = useState(
     initialQueryParams ? createQueryParams(null, initialQueryParams) : null
   );
-  const pathRef = useRef(path);
-  useEffect(() => {
-    pathRef.current = path;
-  }, [path]);
+  const pathRef = useLatest(path);
   const memoizedQueryParamsPathRef = useRef(path);
   const memoizedQueryParams = useMemo(
     () => {
@@ -67,10 +79,7 @@ function useProvideApi({
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [queryParams, relation]
   );
-  const queryParamsRef = useRef(memoizedQueryParams);
-  useEffect(() => {
-    queryParamsRef.current = memoizedQueryParams;
-  }, [memoizedQueryParams]);
+  const queryParamsRef = useLatest(memoizedQueryParams);
   const setQueryParamsCallback = useCallback(
     (partialQueryParams) => setQueryParams((prev) => {
       if (typeof partialQueryParams === "function") {
@@ -98,17 +107,11 @@ function useProvideApi({
     [streamingMode]
   );
   const [error, setError] = useState();
-  const memoizedError = useMemo(() => error, [error]);
   const resetError = useCallback(() => setError(void 0), []);
   const { currentLanguage } = useLang();
-  const {
-    data: info,
-    isFetching: infoLoading,
-    refetch: infoRefetch,
-    error: infoError
-  } = useQuery({
+  const infoQuery = useQuery({
     queryKey: [`info`, path, refetchInfoBasedOnLang ? currentLanguage : ""],
-    queryFn: ({ signal }) => api.getInfo(urlJoin(path, "_info"), { signal, headers: { "Accept-Language": currentLanguage } }).then((data2) => ({ ...convertInfo(data2), path })),
+    queryFn: ({ signal }) => api.getInfo(urlJoin(path, "_info"), { signal, headers: { "Accept-Language": currentLanguage } }).then((data) => ({ ...convertInfo(data), path })),
     placeholderData: clearInfoOnRefetch ? null : keepPreviousData,
     enabled: fetchInfo,
     retry: false,
@@ -117,16 +120,8 @@ function useProvideApi({
     refetchOnWindowFocus: false,
     ...infoQueryProps
   });
-  const infoRef = useRef(info);
-  useEffect(() => {
-    infoRef.current = info;
-  }, [info]);
-  const {
-    data,
-    isFetching: dataLoading,
-    refetch: dataRefetch,
-    error: dataError
-  } = useQuery({
+  const infoRef = useLatest(infoQuery.data);
+  const dataQuery = useQuery({
     queryKey: [
       `data`,
       memoizedQueryParamsPathRef.current,
@@ -136,28 +131,80 @@ function useProvideApi({
     queryFn: ({ signal }) => memoizedQueryParams ? api.getItems(urlJoin(memoizedQueryParamsPathRef.current, "/"), memoizedQueryParams, {
       signal,
       headers: { "Accept-Language": currentLanguage }
-    }).then((data2) => ({
-      ...data2,
-      result: data2.result.map((item, index) => ({ ...item, id: data2.ids[index] })),
+    }).then((data) => ({
+      ...data,
+      result: data.result.map((item, index) => ({ ...item, id: data.ids[index] })),
       path: memoizedQueryParamsPathRef.current,
       queryParams: memoizedQueryParams
     })) : null,
     placeholderData: clearDataOnRefetch ? null : keepPreviousData,
     retry: false,
+    enabled: !streamingMode,
     ...dataQueryProps
   });
+  const streamingQuerySignature = useMemo(() => getStreamingQuerySignature(memoizedQueryParams), [memoizedQueryParams]);
+  const streamingQueryKey = useMemo(
+    () => [
+      `data-streaming`,
+      memoizedQueryParamsPathRef.current,
+      streamingQuerySignature,
+      refetchDataBasedOnLang ? currentLanguage : ""
+    ],
+    [currentLanguage, refetchDataBasedOnLang, streamingQuerySignature]
+  );
+  const streamingQuery = useInfiniteQuery({
+    queryKey: streamingQueryKey,
+    queryFn: ({ signal, pageParam }) => {
+      if (!memoizedQueryParams) {
+        return null;
+      }
+      const page = pageParam ?? memoizedQueryParams.page ?? 0;
+      const params = { ...memoizedQueryParams, page };
+      return api.getItems(urlJoin(memoizedQueryParamsPathRef.current, "/"), params, {
+        signal,
+        headers: { "Accept-Language": currentLanguage }
+      }).then((data) => ({
+        ...data,
+        result: data.result.map((item, index) => ({ ...item, id: data.ids[index] })),
+        path: memoizedQueryParamsPathRef.current,
+        queryParams: params
+      }));
+    },
+    initialPageParam: (memoizedQueryParams == null ? void 0 : memoizedQueryParams.page) ?? 0,
+    getNextPageParam: (lastPage) => {
+      var _a2, _b;
+      if (!lastPage) {
+        return void 0;
+      }
+      const currentPage = ((_a2 = lastPage.queryParams) == null ? void 0 : _a2.page) ?? 0;
+      const pageSize = (_b = lastPage.queryParams) == null ? void 0 : _b.page_size;
+      if (!pageSize || lastPage.result.length < pageSize) {
+        return void 0;
+      }
+      return currentPage + 1;
+    },
+    placeholderData: clearDataOnRefetch ? null : keepPreviousData,
+    retry: false,
+    enabled: streamingMode && !!memoizedQueryParams,
+    ...streamingQueryProps
+  });
+  const { activeDataQuery, streaming } = useStreamingData({
+    streamingMode,
+    dataQuery,
+    streamingQuery,
+    streamingQueryKey
+  });
   useEffect(() => {
-    if (infoError) {
-      setError({ message: `Could not fetch info`, originalError: infoError });
+    if (infoQuery.error) {
+      setError({ message: `Could not fetch info`, originalError: infoQuery.error });
       return;
     }
-    if (dataError) {
-      setError({ message: `Could not fetch list`, originalError: dataError });
+    if (activeDataQuery.error) {
+      setError({ message: `Could not fetch list`, originalError: activeDataQuery.error });
       return;
     }
     resetError();
-  }, [infoError, dataError, resetError]);
-  const loading = useMemo(() => infoLoading || dataLoading, [infoLoading, dataLoading]);
+  }, [activeDataQuery.error, infoQuery.error, resetError]);
   useDidUpdate(() => {
     if (!resetQueryParamsOnPathChange) {
       return;
@@ -168,176 +215,53 @@ function useProvideApi({
     }
     setQueryParams({ ...newQueryParams });
   }, [path]);
-  const getEntry = useCallback(
-    async (id) => {
-      try {
-        resetError();
-        const response = await api.getItem(pathRef.current, convertId(id), {
-          headers: { "Accept-Language": currentLanguage }
-        });
-        return response;
-      } catch (error2) {
-        setError({ message: "Could not fetch item with id {{id}}", data: { id }, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [api, currentLanguage, resetError, throwOnError]
-  );
-  const addEntry = useCallback(
-    async (item) => {
-      var _a;
-      try {
-        resetError();
-        const func = ((_a = infoRef.current) == null ? void 0 : _a.add_type) === "form" ? api.formCreateItem : api.createItem;
-        const response = await func(pathRef.current, item, {
-          headers: { "Accept-Language": currentLanguage }
-        });
-        return response;
-      } catch (error2) {
-        setError({ message: `Could not add item`, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [api.createItem, api.formCreateItem, currentLanguage, resetError, throwOnError]
-  );
-  const updateEntry = useCallback(
-    async (id, item) => {
-      var _a;
-      try {
-        resetError();
-        const func = ((_a = infoRef.current) == null ? void 0 : _a.edit_type) === "form" ? api.formUpdateItem : api.updateItem;
-        const response = await func(pathRef.current, convertId(id), item, {
-          headers: { "Accept-Language": currentLanguage }
-        });
-        return response;
-      } catch (error2) {
-        setError({ message: "Could not update item with id {{id}}", data: { id }, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [api.formUpdateItem, api.updateItem, currentLanguage, resetError, throwOnError]
-  );
-  const deleteEntry = useCallback(
-    async (id) => {
-      try {
-        resetError();
-        const response = await api.deleteItem(pathRef.current, convertId(id), {
-          headers: { "Accept-Language": currentLanguage }
-        });
-        return response;
-      } catch (error2) {
-        setError({ message: "Could not delete item with id {{id}}", data: { id }, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [api, currentLanguage, resetError, throwOnError]
-  );
-  const download = useCallback(
-    async (label, { export_mode, delimiter, quotechar } = {}) => {
-      try {
-        resetError();
-        await api.downloadItems(pathRef.current, queryParamsRef.current, { label, export_mode, delimiter, quotechar });
-      } catch (error2) {
-        setError({ message: `Could not download`, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [api, resetError, throwOnError]
-  );
-  const upload = useCallback(
-    async (file, { delimiter, quotechar } = {}) => {
-      try {
-        resetError();
-        const response = await api.uploadItems(pathRef.current, file, { delimiter, quotechar });
-        return response;
-      } catch (error2) {
-        setError({ message: `Could not upload`, originalError: error2 });
-        if (throwOnError) {
-          throw error2;
-        }
-      }
-    },
-    [api, resetError, throwOnError]
-  );
-  const getItemURL = useCallback(
-    (type, item) => typeof item === "string" ? urlJoin(path, `_${type}`, item) : URL.createObjectURL(item),
-    [path]
-  );
-  const [streaming, setStreaming] = useSetState({
-    data: {},
-    isEnd: false,
-    fetch: streamingMode ? () => setQueryParamsCallback({ page: 0, streaming: true }) : () => null
+  const { getEntry, addEntry, updateEntry, deleteEntry, download, upload, getItemURL } = useApiActions({
+    api,
+    path,
+    pathRef,
+    infoRef,
+    queryParamsRef,
+    currentLanguage,
+    resetError,
+    setError,
+    throwOnError
   });
-  useEffect(() => {
-    if (!streamingMode) {
-      return;
-    }
-    if (!data) {
-      return;
-    }
-    setStreaming((prev) => {
-      var _a;
-      const newStreaming = { isEnd: false };
-      const currentPage = ((_a = data.queryParams) == null ? void 0 : _a.page) ?? 0;
-      const nextPage = currentPage + 1;
-      if (prev.data[nextPage]) {
-        newStreaming.data = {};
-      } else {
-        newStreaming.data = { ...prev.data };
-      }
-      newStreaming.data[currentPage] = data.result;
-      if (data.result.length < data.queryParams.page_size) {
-        newStreaming.isEnd = true;
-        newStreaming.fetch = () => null;
-      } else {
-        newStreaming.fetch = () => setQueryParamsCallback({ page: nextPage, streaming: true });
-      }
-      return newStreaming;
-    });
-  }, [data, setQueryParamsCallback, setStreaming, streamingMode]);
   const specialKey = useMemo(() => {
-    var _a;
+    var _a2, _b;
     const specialKey2 = {
       all: "all",
       actions: "actions"
     };
-    (_a = data == null ? void 0 : data.list_columns) == null ? void 0 : _a.forEach((key) => {
+    (_b = (_a2 = activeDataQuery.data) == null ? void 0 : _a2.list_columns) == null ? void 0 : _b.forEach((key) => {
       if (specialKey2[key]) {
         specialKey2[key] = `_${key}`;
       }
     });
     return specialKey2;
-  }, [data == null ? void 0 : data.list_columns]);
+  }, [(_a = activeDataQuery.data) == null ? void 0 : _a.list_columns]);
   const refetch = useCallback(
-    () => queryParamsRef.current ? dataRefetch() : setQueryParamsCallback(),
-    [dataRefetch, setQueryParamsCallback]
+    () => queryParamsRef.current ? activeDataQuery.refetch() : setQueryParamsCallback(),
+    [activeDataQuery, queryParamsRef, setQueryParamsCallback]
   );
   return {
     path,
-    data,
-    info,
+    data: activeDataQuery.data,
+    info: infoQuery.data,
     queryParams: memoizedQueryParams,
-    loading,
-    infoLoading,
-    dataLoading,
-    error: memoizedError,
-    infoError,
-    dataError,
+    loading: infoQuery.isFetching || activeDataQuery.isFetching,
+    infoLoading: infoQuery.isFetching,
+    dataLoading: activeDataQuery.isFetching,
+    error,
+    infoError: infoQuery.error,
+    dataError: activeDataQuery.error,
+    infoQuery,
+    dataQuery: activeDataQuery,
+    streamingQuery,
     streaming,
     specialKey,
     setQueryParams: setQueryParamsCallback,
     refetch,
-    refetchInfo: infoRefetch,
+    refetchInfo: infoQuery.refetch,
     getEntry,
     addEntry,
     updateEntry,

package/dist/core/esm/Wrappers/ApiProvider/hooks/useProvideForm.mjs

@@ -1,6 +1,6 @@
 import { initialState, VIEW_MODE } from "fastapi-rtk/constants";
 import { useState } from "react";
-import { create } from "../../../../../.external/esm/zustand@5.0.11_@types_react@19.2.14_react@19.2.4/zustand/esm/react.mjs";
+import { create } from "../../../../../.external/esm/zustand@5.0.12_@types_react@19.2.14_react@19.2.4/zustand/esm/react.mjs";
 const useProvideForm = () => {
   const [storeAdd] = useState(
     () => create((set, get) => ({

package/dist/core/esm/Wrappers/ApiProvider/hooks/utils/useApiActions.mjs

@@ -0,0 +1,131 @@
+import { convertId, urlJoin } from "fastapi-rtk/utils";
+import { useCallback } from "react";
+const useApiActions = ({
+  api,
+  path,
+  pathRef,
+  infoRef,
+  queryParamsRef,
+  currentLanguage,
+  resetError,
+  setError,
+  throwOnError
+}) => {
+  const getEntry = useCallback(
+    async (id) => {
+      try {
+        resetError();
+        const response = await api.getItem(pathRef.current, convertId(id), {
+          headers: { "Accept-Language": currentLanguage }
+        });
+        return response;
+      } catch (error) {
+        setError({ message: "Could not fetch item with id {{id}}", data: { id }, originalError: error });
+        if (throwOnError) {
+          throw error;
+        }
+      }
+    },
+    [api, currentLanguage, pathRef, resetError, setError, throwOnError]
+  );
+  const addEntry = useCallback(
+    async (item) => {
+      var _a;
+      try {
+        resetError();
+        const func = ((_a = infoRef.current) == null ? void 0 : _a.add_type) === "form" ? api.formCreateItem : api.createItem;
+        const response = await func(pathRef.current, item, {
+          headers: { "Accept-Language": currentLanguage }
+        });
+        return response;
+      } catch (error) {
+        setError({ message: `Could not add item`, originalError: error });
+        if (throwOnError) {
+          throw error;
+        }
+      }
+    },
+    [api.createItem, api.formCreateItem, currentLanguage, infoRef, pathRef, resetError, setError, throwOnError]
+  );
+  const updateEntry = useCallback(
+    async (id, item) => {
+      var _a;
+      try {
+        resetError();
+        const func = ((_a = infoRef.current) == null ? void 0 : _a.edit_type) === "form" ? api.formUpdateItem : api.updateItem;
+        const response = await func(pathRef.current, convertId(id), item, {
+          headers: { "Accept-Language": currentLanguage }
+        });
+        return response;
+      } catch (error) {
+        setError({ message: "Could not update item with id {{id}}", data: { id }, originalError: error });
+        if (throwOnError) {
+          throw error;
+        }
+      }
+    },
+    [api.formUpdateItem, api.updateItem, currentLanguage, infoRef, pathRef, resetError, setError, throwOnError]
+  );
+  const deleteEntry = useCallback(
+    async (id) => {
+      try {
+        resetError();
+        const response = await api.deleteItem(pathRef.current, convertId(id), {
+          headers: { "Accept-Language": currentLanguage }
+        });
+        return response;
+      } catch (error) {
+        setError({ message: "Could not delete item with id {{id}}", data: { id }, originalError: error });
+        if (throwOnError) {
+          throw error;
+        }
+      }
+    },
+    [api, currentLanguage, pathRef, resetError, setError, throwOnError]
+  );
+  const download = useCallback(
+    async (label, { export_mode, delimiter, quotechar } = {}) => {
+      try {
+        resetError();
+        await api.downloadItems(pathRef.current, queryParamsRef.current, { label, export_mode, delimiter, quotechar });
+      } catch (error) {
+        setError({ message: `Could not download`, originalError: error });
+        if (throwOnError) {
+          throw error;
+        }
+      }
+    },
+    [api, pathRef, queryParamsRef, resetError, setError, throwOnError]
+  );
+  const upload = useCallback(
+    async (file, { delimiter, quotechar } = {}) => {
+      try {
+        resetError();
+        const response = await api.uploadItems(pathRef.current, file, { delimiter, quotechar });
+        return response;
+      } catch (error) {
+        setError({ message: `Could not upload`, originalError: error });
+        if (throwOnError) {
+          throw error;
+        }
+      }
+    },
+    [api, pathRef, resetError, setError, throwOnError]
+  );
+  const getItemURL = useCallback(
+    (type, item) => typeof item === "string" ? urlJoin(path, `_${type}`, item) : URL.createObjectURL(item),
+    [path]
+  );
+  return {
+    getEntry,
+    addEntry,
+    updateEntry,
+    deleteEntry,
+    download,
+    upload,
+    getItemURL
+  };
+};
+export {
+  useApiActions
+};

package/dist/core/esm/Wrappers/ApiProvider/hooks/utils/useLatest.mjs

@@ -0,0 +1,11 @@
+import { useRef, useEffect } from "react";
+const useLatest = (value) => {
+  const ref = useRef(value);
+  useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+};
+export {
+  useLatest
+};

package/dist/core/esm/Wrappers/ApiProvider/hooks/utils/useStreamingData.mjs

@@ -0,0 +1,90 @@
+import { useQueryClient } from "../../../../../../.external/esm/@tanstack_react-query@5.91.3_react@19.2.4/@tanstack/react-query/build/modern/QueryClientProvider.mjs";
+import { useMemo, useCallback } from "react";
+const useStreamingData = ({ streamingMode, dataQuery, streamingQuery, streamingQueryKey }) => {
+  var _a;
+  const queryClient = useQueryClient();
+  const streamingPages = useMemo(() => {
+    var _a2;
+    return ((_a2 = streamingQuery.data) == null ? void 0 : _a2.pages) || [];
+  }, [(_a = streamingQuery.data) == null ? void 0 : _a.pages]);
+  const activeDataQuery = useMemo(() => {
+    if (!streamingMode) {
+      return dataQuery;
+    }
+    const currentPageData = streamingPages.at(-1) || null;
+    return {
+      ...streamingQuery,
+      data: currentPageData
+    };
+  }, [dataQuery, streamingMode, streamingPages, streamingQuery]);
+  const fetchStreamingPage = useCallback(() => {
+    if (!streamingMode || streamingQuery.isFetchingNextPage) {
+      return null;
+    }
+    if (streamingPages.length === 0) {
+      return streamingQuery.refetch();
+    }
+    if (!streamingQuery.hasNextPage) {
+      return null;
+    }
+    return streamingQuery.fetchNextPage();
+  }, [streamingMode, streamingPages.length, streamingQuery]);
+  const resetStreamingPages = useCallback(
+    async ({ refetch = true } = {}) => {
+      if (!streamingMode) {
+        return null;
+      }
+      await queryClient.cancelQueries({ queryKey: streamingQueryKey });
+      queryClient.setQueryData(streamingQueryKey, (previousData) => {
+        if (!previousData) {
+          return previousData;
+        }
+        return {
+          ...previousData,
+          pages: [],
+          pageParams: []
+        };
+      });
+      if (refetch) {
+        return streamingQuery.refetch();
+      }
+      return null;
+    },
+    [queryClient, streamingMode, streamingQuery, streamingQueryKey]
+  );
+  const streaming = useMemo(() => {
+    if (!streamingMode) {
+      return {
+        data: {},
+        isEnd: false,
+        fetch: async () => null,
+        reset: async () => null
+      };
+    }
+    const data = streamingPages.reduce((acc, page) => {
+      var _a2;
+      if (!page) {
+        return acc;
+      }
+      const pageNumber = ((_a2 = page.queryParams) == null ? void 0 : _a2.page) ?? 0;
+      acc[pageNumber] = page.result;
+      return acc;
+    }, {});
+    return {
+      data,
+      isEnd: streamingPages.length > 0 ? !streamingQuery.hasNextPage : false,
+      fetch: fetchStreamingPage,
+      reset: resetStreamingPages
+    };
+  }, [fetchStreamingPage, resetStreamingPages, streamingMode, streamingPages, streamingQuery.hasNextPage]);
+  return {
+    streamingPages,
+    activeDataQuery,
+    fetchStreamingPage,
+    resetStreamingPages,
+    streaming
+  };
+};
+export {
+  useStreamingData
+};

package/dist/core/esm/Wrappers/Provider/Contexts/LangContext.mjs

@@ -3,12 +3,12 @@ import { LANG_LOCAL_STORAGE_PROPS } from "fastapi-rtk/constants";
 import { createSafeContext, parseFromValuesOrFunc } from "fastapi-rtk/utils";
 import { useProxy } from "fastapi-rtk/zustand";
 import { useLocalStorage } from "@mantine/hooks";
-import { createInstance } from "../../../../../.external/esm/i18next@25.8.18_typescript@5.9.3/i18next/dist/esm/i18next.mjs";
+import { createInstance } from "../../../../../.external/esm/i18next@25.8.20_typescript@5.9.3/i18next/dist/esm/i18next.mjs";
 import { useRef, useMemo, useEffect } from "react";
 import de from "../../../translations/de.mjs";
 import { useProvideLang } from "../hooks/useProvideLang.mjs";
-import { I18nextProvider } from "../../../../../.external/esm/react-i18next@15.7.4_i18next@25.8.18_react-dom@19.2.4_react@19.2.4_typescript@5.9.3/react-i18next/dist/es/I18nextProvider.mjs";
-import { initReactI18next } from "../../../../../.external/esm/react-i18next@15.7.4_i18next@25.8.18_react-dom@19.2.4_react@19.2.4_typescript@5.9.3/react-i18next/dist/es/initReactI18next.mjs";
+import { I18nextProvider } from "../../../../../.external/esm/react-i18next@15.7.4_i18next@25.8.20_react-dom@19.2.4_react@19.2.4_typescript@5.9.3/react-i18next/dist/es/I18nextProvider.mjs";
+import { initReactI18next } from "../../../../../.external/esm/react-i18next@15.7.4_i18next@25.8.20_react-dom@19.2.4_react@19.2.4_typescript@5.9.3/react-i18next/dist/es/initReactI18next.mjs";
 const getI18n = ({ initProps, callback, translations } = {}) => {
   var _a, _b, _c, _d, _e, _f, _g, _h;
   const i18n = createInstance();

package/dist/core/esm/Wrappers/Provider/Provider.mjs

@@ -2,8 +2,8 @@ import { jsx } from "react/jsx-runtime";
 import { setDebugMode } from "fastapi-rtk/constants";
 import { parseFromValuesOrFunc } from "fastapi-rtk/utils";
 import { useProxy } from "fastapi-rtk/zustand";
-import { QueryClient } from "../../../../.external/esm/@tanstack_query-core@5.90.20/@tanstack/query-core/build/modern/queryClient.mjs";
-import { QueryClientProvider } from "../../../../.external/esm/@tanstack_react-query@5.90.21_react@19.2.4/@tanstack/react-query/build/modern/QueryClientProvider.mjs";
+import { QueryClient } from "../../../../.external/esm/@tanstack_query-core@5.91.2/@tanstack/query-core/build/modern/queryClient.mjs";
+import { QueryClientProvider } from "../../../../.external/esm/@tanstack_react-query@5.91.3_react@19.2.4/@tanstack/react-query/build/modern/QueryClientProvider.mjs";
 import { useState, forwardRef, useMemo, useEffect } from "react";
 import { defaultAuth } from "../../fab-react-toolkit-patch/auth/hooks/useProvideAuth.mjs";
 import { defaultInfo } from "../../fab-react-toolkit-patch/auth/hooks/useProvideInfo.mjs";