fastapi-rtk 2.8.0 → 2.9.0

package/dist/api/esm/Provider/hooks/useProvideLang.mjs

@@ -0,0 +1,76 @@
+import { LANG_LOCAL_STORAGE_PROPS, MRT_LOCALIZATION_IMPORT_MAP } from "fastapi-rtk/constants";
+import { FastAPIRTKLogger } from "fastapi-rtk/utils";
+import { useState, useEffect, useCallback } from "react";
+import { useAdapters } from "../../adapters/AdaptersContext.mjs";
+import { useTranslation } from "../../../../.external/esm/react-i18next@15.7.4_i18next@25.8.0_typescript@5.9.3__react-dom@19.2.3_react@19.2.3__react@19.2.3_typescript@5.9.3/react-i18next/dist/es/useTranslation.mjs";
+const useProvideLang = (baseMRTLocalization = {}) => {
+  const translation = useTranslation();
+  const adapters = useAdapters();
+  const [localStorageLanguage, setStoredLanguage] = useState(LANG_LOCAL_STORAGE_PROPS.defaultValue);
+  useEffect(() => {
+    var _a, _b;
+    Promise.resolve(adapters.storage.get(LANG_LOCAL_STORAGE_PROPS.key)).then((v) => {
+      if (v) {
+        setStoredLanguage(v);
+      }
+    });
+    return (_b = (_a = adapters.storage).subscribe) == null ? void 0 : _b.call(_a, LANG_LOCAL_STORAGE_PROPS.key, (v) => {
+      if (v) {
+        setStoredLanguage(v);
+      }
+    });
+  }, [adapters.storage]);
+  const setLocalStorageLanguage = useCallback(
+    (lng) => {
+      setStoredLanguage(lng);
+      adapters.storage.set(LANG_LOCAL_STORAGE_PROPS.key, lng);
+    },
+    [adapters.storage]
+  );
+  const setLanguage = useCallback(
+    (lng) => {
+      translation.i18n.changeLanguage(lng).then(() => setLocalStorageLanguage(lng));
+    },
+    [setLocalStorageLanguage, translation.i18n]
+  );
+  const [MRTLocalization, setMRTLocalizationState] = useState(baseMRTLocalization);
+  const setMRTLocalization = useCallback(
+    (partial) => (
+      // #MUSTASSERT spreading a Partial index-signature map widens values to `| undefined`; only fully-defined locale maps are ever merged
+      setMRTLocalizationState((prev) => ({ ...prev, ...partial }))
+    ),
+    []
+  );
+  useEffect(() => {
+    if (!translation.i18n.language) {
+      return;
+    }
+    const language = translation.i18n.language;
+    if (!(MRTLocalization == null ? void 0 : MRTLocalization[language])) {
+      if (!MRT_LOCALIZATION_IMPORT_MAP[language]) {
+        FastAPIRTKLogger.error(
+          `No localization found for '${language}', consider adding it yourself using 'MRTLocalization' prop within the 'langProps' in 'Provider' component. See here for the keys: https://github.com/KevinVandy/mantine-react-table/blob/v2/packages/mantine-react-table/src/locales/en.ts`
+        );
+        return;
+      }
+      MRT_LOCALIZATION_IMPORT_MAP[language]().then((languagePack) => {
+        const pack = { [language]: languagePack };
+        setMRTLocalization(pack);
+      }).catch(() => FastAPIRTKLogger.error(`Failed to load localization for ${language}`));
+    }
+  }, [translation.i18n.language]);
+  return {
+    currentLanguage: translation.i18n.language,
+    setLanguage,
+    translation,
+    useTranslation,
+    currentMRTLocalization: MRTLocalization[translation.i18n.language],
+    MRTLocalization,
+    setMRTLocalization,
+    localStorageLanguage,
+    setLocalStorageLanguage
+  };
+};
+export {
+  useProvideLang
+};

package/dist/api/esm/_virtual/_commonjsHelpers.mjs

@@ -0,0 +1,6 @@
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+export {
+  getDefaultExportFromCjs
+};

package/dist/api/esm/_virtual/index.mjs

@@ -0,0 +1,5 @@
+import { __require as requirePropertyExpr } from "../../../.external/esm/property-expr@2.0.6/property-expr/index.mjs";
+var propertyExprExports = requirePropertyExpr();
+export {
+  propertyExprExports as p
+};

package/dist/api/esm/_virtual/index2.mjs

@@ -0,0 +1,5 @@
+import { __require as requireTinyCase } from "../../../.external/esm/tiny-case@1.0.3/tiny-case/index.mjs";
+var tinyCaseExports = requireTinyCase();
+export {
+  tinyCaseExports as t
+};

package/dist/api/esm/_virtual/index3.mjs

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from "./_commonjsHelpers.mjs";
+import { __require as requireToposort } from "../../../.external/esm/toposort@2.0.2/toposort/index.mjs";
+var toposortExports = requireToposort();
+const toposort = /* @__PURE__ */ getDefaultExportFromCjs(toposortExports);
+export {
+  toposort as default
+};

package/dist/api/esm/_virtual/index4.mjs

@@ -0,0 +1,4 @@
+var toposort = { exports: {} };
+export {
+  toposort as __module
+};

package/dist/api/esm/adapters/AdaptersContext.mjs

@@ -0,0 +1,10 @@
+import { createSafeContext } from "fastapi-rtk/utils";
+const [AdaptersProvider, useAdaptersProvider] = createSafeContext(
+  "useAdapters must be used within a Provider"
+);
+const useAdapters = (options) => useAdaptersProvider(options);
+export {
+  AdaptersProvider,
+  useAdapters,
+  useAdaptersProvider
+};

package/dist/api/esm/auth/authFetch.mjs

@@ -0,0 +1,63 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "../fetchers/request.mjs";
+async function authSignin(adapters, baseUrl, credentials) {
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth", adapters.authTransport.loginPath), method: "POST" },
+    adapters
+  );
+  const res = await adapters.network.request(fetchPath, {
+    ...options,
+    headers: { ...options.headers, "Content-Type": "application/x-www-form-urlencoded" },
+    body: adapters.authTransport.buildLoginBody(credentials)
+  });
+  if (!res.ok) {
+    if (res.status === 400) {
+      throw new Error("Username or password wrong.");
+    } else {
+      throw new Error("Failed to sign in.");
+    }
+  }
+  await adapters.authTransport.persistLogin(res);
+}
+async function authSignout(adapters, baseUrl) {
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth/logout"), method: "POST" },
+    adapters
+  );
+  const res = await adapters.network.request(fetchPath, options);
+  if (!res.ok) {
+    throw new Error("Failed to sign out.");
+  }
+  await adapters.authTransport.clearLogin();
+}
+async function authResetPassword(adapters, baseUrl, newPassword, { email }) {
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth/forgot-password"), method: "POST", body: { email } },
+    adapters
+  );
+  const forgotPasswordRes = await adapters.network.request(fetchPath, options);
+  const { token } = await parseResponse(forgotPasswordRes);
+  const { fetchPath: fetchPath2, options: options2 } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth/reset-password"), method: "POST", body: { token, password: newPassword } },
+    adapters
+  );
+  const resetPasswordRes = await adapters.network.request(fetchPath2, options2);
+  await parseResponse(resetPasswordRes);
+}
+async function authOAuthSignin(adapters, baseUrl, provider, popup, afterSigninPopup) {
+  const url = urlJoin(baseUrl, "auth/login", provider);
+  await adapters.oauthOpener.open(url, { popup, onClose: afterSigninPopup });
+}
+async function authInfo(adapters, baseUrl, signal) {
+  const { fetchPath, options } = await buildRequest({ path: urlJoin(baseUrl, "info/"), method: "GET" }, adapters);
+  const res = await adapters.network.request(fetchPath, { signal, ...options });
+  return await parseResponse(res);
+}
+export {
+  authInfo,
+  authOAuthSignin,
+  authResetPassword,
+  authSignin,
+  authSignout
+};

package/dist/api/esm/auth/userCRUD.mjs

@@ -0,0 +1,20 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "../fetchers/request.mjs";
+async function getUser(adapters, baseUrl, signal) {
+  const { fetchPath, options } = await buildRequest({ path: urlJoin(baseUrl, "auth/user"), method: "GET" }, adapters);
+  const res = await adapters.network.request(fetchPath, { signal, ...options });
+  return await parseResponse(res);
+}
+async function updateUser(adapters, baseUrl, userData) {
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(baseUrl, "auth/user"), method: "PUT", body: userData },
+    adapters
+  );
+  const res = await adapters.network.request(fetchPath, options);
+  return await parseResponse(res);
+}
+export {
+  getUser,
+  updateUser
+};

package/dist/api/esm/fetchers/createItem.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const createItem = async (adapters, path, data, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, "/"), method: "POST", body: data, options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  createItem
+};

package/dist/api/esm/fetchers/deleteItem.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const deleteItem = async (adapters, path, id, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, id.toString()), method: "DELETE", options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  deleteItem
+};

package/dist/api/esm/fetchers/downloadItems.mjs

@@ -0,0 +1,33 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const downloadItems = async (adapters, path, queryParams, { label, export_mode, delimiter, quotechar } = {}) => {
+  const _queryParams = { ...queryParams, check_validity: true };
+  if (label) {
+    _queryParams.label = label;
+  }
+  if (export_mode) {
+    _queryParams.export_mode = export_mode;
+  }
+  if (delimiter) {
+    _queryParams.delimiter = delimiter;
+  }
+  if (quotechar) {
+    _queryParams.quotechar = quotechar;
+  }
+  const { fetchPath: fetchPatchCheck, options: optionsCheck } = await buildRequest(
+    { path: urlJoin(path, "/download"), method: "GET", queryParams: _queryParams },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPatchCheck, optionsCheck);
+  await parseResponse(response);
+  delete _queryParams.check_validity;
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(path, "/download"), method: "GET", queryParams: _queryParams },
+    adapters
+  );
+  await adapters.fileDownload.save({ url: fetchPath, filename: label, headers: options.headers });
+};
+export {
+  downloadItems
+};

package/dist/api/esm/fetchers/formCreateItem.mjs

@@ -0,0 +1,18 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { convertToFormData } from "../utils/convertToFormData/convertToFormData.mjs";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const formCreateItem = async (adapters, path, data, options) => {
+  const formData = convertToFormData(data, adapters.formData);
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, "/"), method: "POST", options },
+    adapters
+  );
+  delete fetchOptions["headers"]["Content-Type"];
+  fetchOptions["body"] = formData;
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  formCreateItem
+};

package/dist/api/esm/fetchers/formUpdateItem.mjs

@@ -0,0 +1,18 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { convertToFormData } from "../utils/convertToFormData/convertToFormData.mjs";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const formUpdateItem = async (adapters, path, id, data, options) => {
+  const formData = convertToFormData(data, adapters.formData);
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, id.toString()), method: "PUT", options },
+    adapters
+  );
+  delete fetchOptions["headers"]["Content-Type"];
+  fetchOptions["body"] = formData;
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  formUpdateItem
+};

package/dist/api/esm/fetchers/getInfo.mjs

@@ -0,0 +1,10 @@
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const getInfo = async (adapters, path, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest({ path, method: "GET", options }, adapters);
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  getInfo
+};

package/dist/api/esm/fetchers/getItem.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const getItem = async (adapters, path, id, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, id.toString()), method: "GET", options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  getItem
+};

package/dist/api/esm/fetchers/getItems.mjs

@@ -0,0 +1,13 @@
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const getItems = async (adapters, path, queryParams, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path, method: "GET", queryParams, options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  getItems
+};

package/dist/api/esm/fetchers/postBulkAction.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const postBulk = async (adapters, path, handler, data, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, "/bulk", handler), method: "POST", body: data, options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  postBulk
+};

package/dist/api/esm/fetchers/request.mjs

@@ -0,0 +1,9 @@
+import { createFetchParams } from "../utils/createFetchParams/createFetchParams.mjs";
+const buildRequest = async (args, adapters) => {
+  const { fetchPath, options } = createFetchParams(args);
+  const decorated = await adapters.authTransport.decorateRequest(options);
+  return { fetchPath, options: decorated };
+};
+export {
+  buildRequest
+};

package/dist/api/esm/fetchers/updateItem.mjs

@@ -0,0 +1,14 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const updateItem = async (adapters, path, id, data, options) => {
+  const { fetchPath, options: fetchOptions } = await buildRequest(
+    { path: urlJoin(path, id.toString()), method: "PUT", body: data, options },
+    adapters
+  );
+  const response = await adapters.network.request(fetchPath, fetchOptions);
+  return await parseResponse(response);
+};
+export {
+  updateItem
+};

package/dist/api/esm/fetchers/uploadItems.mjs

@@ -0,0 +1,24 @@
+import { urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "../utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./request.mjs";
+const uploadItems = async (adapters, path, file, { delimiter, quotechar } = {}) => {
+  const formData = new FormData();
+  adapters.formData.appendFile(formData, "file", file);
+  const queryParams = {};
+  if (delimiter) {
+    queryParams.delimiter = delimiter;
+  }
+  if (quotechar) {
+    queryParams.quotechar = quotechar;
+  }
+  const { fetchPath, options } = await buildRequest(
+    { path: urlJoin(path, "/upload"), method: "POST", queryParams },
+    adapters
+  );
+  delete options.headers["Content-Type"];
+  const response = await adapters.network.request(fetchPath, { ...options, body: formData });
+  return await parseResponse(response);
+};
+export {
+  uploadItems
+};

package/dist/{core → api}/esm/hooks/auth/useAuth.mjs

@@ -1,4 +1,4 @@
-import { useAuthProvider } from "../../Wrappers/Provider/Contexts/AuthContext.mjs";
+import { useAuthProvider } from "../../Provider/Contexts/AuthContext.mjs";
 const useAuth = (options) => (
   // #MUSTASSERT the AuthContext is created from an untyped createSafeContext, so the provider hook returns unknown
   useAuthProvider(options)

package/dist/{core → api}/esm/hooks/auth/useInfo.mjs

@@ -1,4 +1,4 @@
-import { useInfoProvider } from "../../Wrappers/Provider/Contexts/InfoContext.mjs";
+import { useInfoProvider } from "../../Provider/Contexts/InfoContext.mjs";
 const useInfo = (options) => (
   // #MUSTASSERT the InfoContext is created from an untyped createSafeContext, so the provider hook returns unknown
   useInfoProvider(options)

package/dist/api/esm/hooks/useDidUpdate.mjs

@@ -0,0 +1,20 @@
+import { useRef, useEffect } from "react";
+const useDidUpdate = (fn, dependencies) => {
+  const mounted = useRef(false);
+  useEffect(
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+  useEffect(() => {
+    if (mounted.current) {
+      return fn();
+    }
+    mounted.current = true;
+    return void 0;
+  }, dependencies);
+};
+export {
+  useDidUpdate
+};

package/dist/api/esm/index.mjs

@@ -0,0 +1,75 @@
+import { AdaptersProvider, useAdapters, useAdaptersProvider } from "./adapters/AdaptersContext.mjs";
+import { authInfo, authOAuthSignin, authResetPassword, authSignin, authSignout } from "./auth/authFetch.mjs";
+import { getUser, updateUser } from "./auth/userCRUD.mjs";
+import { convertToFormData } from "./utils/convertToFormData/convertToFormData.mjs";
+import { createFetchParams } from "./utils/createFetchParams/createFetchParams.mjs";
+import { parseResponse } from "./utils/parseResponse/parseResponse.mjs";
+import { buildRequest } from "./fetchers/request.mjs";
+import { getItems } from "./fetchers/getItems.mjs";
+import { getItem } from "./fetchers/getItem.mjs";
+import { createItem } from "./fetchers/createItem.mjs";
+import { updateItem } from "./fetchers/updateItem.mjs";
+import { deleteItem } from "./fetchers/deleteItem.mjs";
+import { getInfo } from "./fetchers/getInfo.mjs";
+import { formCreateItem } from "./fetchers/formCreateItem.mjs";
+import { formUpdateItem } from "./fetchers/formUpdateItem.mjs";
+import { uploadItems } from "./fetchers/uploadItems.mjs";
+import { downloadItems } from "./fetchers/downloadItems.mjs";
+import { postBulk } from "./fetchers/postBulkAction.mjs";
+import { Provider, withProvider } from "./Provider/Provider.mjs";
+import { AuthContextProvider, useAuthProvider } from "./Provider/Contexts/AuthContext.mjs";
+import { InfoContextProvider, useInfoProvider } from "./Provider/Contexts/InfoContext.mjs";
+import { ApiProvider, withApiProvider } from "./ApiProvider/ApiProvider.mjs";
+import { BulkActionsContextProvider, useBulkActionsProvider } from "./ApiProvider/Contexts/BulkActionsContext.mjs";
+import { FormContextAddProvider, FormContextDeleteProvider, FormContextEditProvider, FormContextViewProvider, useFormAddProvider, useFormDeleteProvider, useFormEditProvider, useFormViewProvider } from "./ApiProvider/Contexts/FormContext.mjs";
+import { useAuth } from "./hooks/auth/useAuth.mjs";
+import { useInfo } from "./hooks/auth/useInfo.mjs";
+import { useDidUpdate } from "./hooks/useDidUpdate.mjs";
+export {
+  AdaptersProvider,
+  ApiProvider,
+  AuthContextProvider,
+  BulkActionsContextProvider,
+  FormContextAddProvider,
+  FormContextDeleteProvider,
+  FormContextEditProvider,
+  FormContextViewProvider,
+  InfoContextProvider,
+  Provider,
+  authInfo,
+  authOAuthSignin,
+  authResetPassword,
+  authSignin,
+  authSignout,
+  buildRequest,
+  convertToFormData,
+  createFetchParams,
+  createItem,
+  deleteItem,
+  downloadItems,
+  formCreateItem,
+  formUpdateItem,
+  getInfo,
+  getItem,
+  getItems,
+  getUser,
+  parseResponse,
+  postBulk,
+  updateItem,
+  updateUser,
+  uploadItems,
+  useAdapters,
+  useAdaptersProvider,
+  useAuth,
+  useAuthProvider,
+  useBulkActionsProvider,
+  useDidUpdate,
+  useFormAddProvider,
+  useFormDeleteProvider,
+  useFormEditProvider,
+  useFormViewProvider,
+  useInfo,
+  useInfoProvider,
+  withApiProvider,
+  withProvider
+};

package/dist/{utils/esm → api/esm/utils}/convertToFormData/convertToFormData.mjs

@@ -1,4 +1,4 @@
-const convertToFormData = (data) => {
+const convertToFormData = (data, formDataAdapter) => {
   const formData = new FormData();
   Object.entries(data).forEach(([key, value]) => {
     if (value === void 0) {
@@ -9,17 +9,17 @@ const convertToFormData = (data) => {
         formData.append(key, null);
         return;
       }
-      const files = value.filter((item) => item instanceof File);
-      const stringValues = value.filter((item) => !(item instanceof File));
+      const files = value.filter((item) => formDataAdapter.isFilePart(item));
+      const stringValues = value.filter((item) => !formDataAdapter.isFilePart(item));
       files.forEach((file) => {
-        formData.append(key, file);
+        formDataAdapter.appendFile(formData, key, file);
       });
       stringValues.forEach((file) => {
         formData.append(key, file);
       });
       return;
     }
-    if (value && typeof value === "object" && !(value instanceof File)) {
+    if (value && typeof value === "object" && !formDataAdapter.isFilePart(value)) {
       formData.append(key, JSON.stringify(value));
       return;
     }

package/dist/{utils/esm → api/esm/utils}/createFetchParams/createFetchParams.mjs

@@ -1,4 +1,3 @@
-import { createSearchParams } from "react-router";
 function createFetchParams(args) {
   const { method, body, queryParams, options: userOptions } = args;
   let path = args.path;
@@ -9,7 +8,7 @@ function createFetchParams(args) {
     acc[key] = String(value);
     return acc;
   }, {});
-  const searchParams = createSearchParams(data);
+  const searchParams = new URLSearchParams(data);
   if (searchParams.size > 0) {
     path = path + "?" + searchParams;
   }
@@ -17,7 +16,6 @@ function createFetchParams(args) {
     // #MUSTANNOTATE string literals like 'include' widen to string without the annotation; indexed-access type constrains them
     method,
     mode: "cors",
-    credentials: "include",
     redirect: "follow",
     referrerPolicy: "no-referrer",
     body: body ? JSON.stringify(body) : null,

package/dist/api/lib/ApiProvider/ApiProvider.d.ts

@@ -0,0 +1,17 @@
+import { ComponentType } from 'react';
+import { ApiProviderProps, WithApiProviderOptions } from './types';
+/**
+ * Provides the API context, bulk actions context, and form contexts to its children.
+ */
+export declare function ApiProvider<TQuery extends object = object>(props: ApiProviderProps<TQuery>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Higher-order component to wrap a component with ApiProvider.
+ *
+ * @param apiProviderProps - The props to be passed to the ApiProvider or a function that returns them.
+ * @param Component - The component to be wrapped.
+ * @param options - Additional options for the HOC.
+ * @returns The wrapped component.
+ */
+export declare const withApiProvider: <P extends object>(apiProviderProps: ApiProviderProps | ((props: P) => ApiProviderProps), Component: ComponentType<P>, options?: WithApiProviderOptions) => ComponentType<P> & {
+    displayName?: string;
+};

package/dist/{core/lib/Wrappers → api/lib}/ApiProvider/Contexts/BulkActionsContext.d.ts

@@ -1,2 +1,2 @@
-import { BulkActionsContextValue } from '../../../hooks/api/types';
+import { BulkActionsContextValue } from '../hooks/types';
 export declare const BulkActionsContextProvider: import('react').Provider<BulkActionsContextValue | null>, useBulkActionsProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<BulkActionsContextValue>) => BulkActionsContextValue;

package/dist/api/lib/ApiProvider/Contexts/FormContext.d.ts

@@ -0,0 +1,5 @@
+import { FormsContextValue } from '../hooks/types';
+export declare const FormContextViewProvider: import('react').Provider<FormsContextValue<import('fastapi-rtk/api-types').ResultRow> | null>, useFormViewProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('fastapi-rtk/api-types').ResultRow>>) => FormsContextValue<import('fastapi-rtk/api-types').ResultRow>;
+export declare const FormContextAddProvider: import('react').Provider<FormsContextValue<import('fastapi-rtk/api-types').ResultRow> | null>, useFormAddProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('fastapi-rtk/api-types').ResultRow>>) => FormsContextValue<import('fastapi-rtk/api-types').ResultRow>;
+export declare const FormContextEditProvider: import('react').Provider<FormsContextValue<import('fastapi-rtk/api-types').ResultRow> | null>, useFormEditProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('fastapi-rtk/api-types').ResultRow>>) => FormsContextValue<import('fastapi-rtk/api-types').ResultRow>;
+export declare const FormContextDeleteProvider: import('react').Provider<FormsContextValue<import('fastapi-rtk/api-types').ResultRow> | null>, useFormDeleteProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('fastapi-rtk/api-types').ResultRow>>) => FormsContextValue<import('fastapi-rtk/api-types').ResultRow>;