fastapi-rtk 0.1.18 → 0.1.19

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

@@ -1,22 +1,37 @@
 import { jsx } from "react/jsx-runtime";
 import { useProxy } from "fastapi-rtk/zustand";
-import { QueryClient } from "../../../../.external/esm/@tanstack_query-core@5.75.7/@tanstack/query-core/build/modern/queryClient.mjs";
-import { QueryClientProvider } from "../../../../.external/esm/@tanstack_react-query@5.75.7_react@18.3.1/@tanstack/react-query/build/modern/QueryClientProvider.mjs";
+import { QueryClient } from "../../../../.external/esm/@tanstack_query-core@5.76.0/@tanstack/query-core/build/modern/queryClient.mjs";
+import { QueryClientProvider } from "../../../../.external/esm/@tanstack_react-query@5.76.1_react@18.3.1/@tanstack/react-query/build/modern/QueryClientProvider.mjs";
 import { useState } from "react";
+import { useFabProvideAuth } from "../../fab-react-toolkit-patch/auth/hooks/useProvideAuth.mjs";
+import { useFabProvideInfo } from "../../fab-react-toolkit-patch/auth/hooks/useProvideInfo.mjs";
 import { AuthContext } from "./Contexts/AuthContext.mjs";
 import { InfoContext } from "./Contexts/InfoContext.mjs";
 import { useProvideAuth } from "./hooks/useProvideAuth.mjs";
 import { useProvideInfo } from "./hooks/useProvideInfo.mjs";
+function useAuth(baseUrl, authQueryProps, fab) {
+  if (fab) {
+    return useFabProvideAuth(baseUrl, authQueryProps);
+  }
+  return useProvideAuth(baseUrl, authQueryProps);
+}
+function useInfo(baseUrl, auth, fab) {
+  if (fab) {
+    return useFabProvideInfo(baseUrl, auth);
+  }
+  return useProvideInfo(baseUrl, auth);
+}
 function InnerProvider(providerProps) {
   const defaultproviderProps = { baseUrl: new URL(document.baseURI).pathname + "/api/v1", inheritMantineTheme: false };
   const { baseUrl, authQueryProps, children } = { ...defaultproviderProps, ...providerProps };
-  const auth = useProvideAuth(baseUrl, authQueryProps);
+  const auth = useAuth(baseUrl, authQueryProps, providerProps.fab);
   const authProxy = useProxy(auth);
-  const info = useProvideInfo(baseUrl, auth);
+  const info = useInfo(baseUrl, auth, providerProps.fab);
   const infoProxy = useProxy(info);
   return /* @__PURE__ */ jsx(AuthContext.Provider, { value: authProxy, children: /* @__PURE__ */ jsx(InfoContext.Provider, { value: infoProxy, children }) });
 }
-const Provider = (props) => {
+const Provider = ({ fab, baseUrl, authQueryProps, ...rest }) => {
+  const props = { fab, baseUrl, authQueryProps, ...rest };
   const [queryClient] = useState(() => new QueryClient());
   return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(InnerProvider, { ...props }) });
 };

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

@@ -1,5 +1,5 @@
-import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.75.7_react@18.3.1/@tanstack/react-query/build/modern/useQuery.mjs";
-import { useQueryClient } from "../../../../../.external/esm/@tanstack_react-query@5.75.7_react@18.3.1/@tanstack/react-query/build/modern/QueryClientProvider.mjs";
+import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.76.1_react@18.3.1/@tanstack/react-query/build/modern/useQuery.mjs";
+import { useQueryClient } from "../../../../../.external/esm/@tanstack_react-query@5.76.1_react@18.3.1/@tanstack/react-query/build/modern/QueryClientProvider.mjs";
 import { useState, useCallback } from "react";
 import { authSignin, authSignout, authResetPassword, authOAuthSignin } from "../utils/authFetch.mjs";
 import { getUser, updateUser } from "../utils/userCRUD.mjs";

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

@@ -1,4 +1,4 @@
-import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.75.7_react@18.3.1/@tanstack/react-query/build/modern/useQuery.mjs";
+import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.76.1_react@18.3.1/@tanstack/react-query/build/modern/useQuery.mjs";
 import { useEffect } from "react";
 import { authInfo } from "../utils/authFetch.mjs";
 function useProvideInfo(baseUrl, auth) {

package/dist/core/esm/fab-react-toolkit-patch/api/hooks/useProvideApi.mjs

@@ -0,0 +1,307 @@
+import { useState, useRef, useEffect, useMemo, useCallback } from "react";
+import { urlJoin } from "fastapi-rtk/utils";
+import { useDidUpdate, useSetState } from "@mantine/hooks";
+import { keepPreviousData } from "../../../../../.external/esm/@tanstack_query-core@5.76.0/@tanstack/query-core/build/modern/utils.mjs";
+import { useQuery } from "../../../../../.external/esm/@tanstack_react-query@5.76.1_react@18.3.1/@tanstack/react-query/build/modern/useQuery.mjs";
+import { createItem } from "../utils/api/createItem.mjs";
+import { deleteItem } from "../utils/api/deleteItem.mjs";
+import { downloadItems } from "../utils/api/downloadItems.mjs";
+import { getInfo } from "../utils/api/getInfo.mjs";
+import { getItem } from "../utils/api/getItem.mjs";
+import { getItems } from "../utils/api/getItems.mjs";
+import { updateItem } from "../utils/api/updateItem.mjs";
+import { uploadItems } from "../utils/api/uploadItems.mjs";
+import { convertId } from "../utils/convertId.mjs";
+import { convertInfo } from "../utils/convertInfo.mjs";
+import { createQueryParams } from "../utils/createQueryParams.mjs";
+function useFabProvideApi({
+  path,
+  initialQueryParams,
+  relation,
+  fetchInfo = true,
+  clearInfoOnRefetch = false,
+  clearDataOnRefetch = false,
+  resetQueryParamsOnPathChange = true,
+  infoQueryProps,
+  dataQueryProps,
+  throwOnError = false,
+  streaming: streamingMode = false
+}) {
+  const [queryParams, setQueryParams] = useState(
+    initialQueryParams ? createQueryParams(null, initialQueryParams) : null
+  );
+  const pathRef = useRef(path);
+  useEffect(() => {
+    pathRef.current = path;
+  }, [path]);
+  const memoizedQueryParamsPathRef = useRef(path);
+  const memoizedQueryParams = useMemo(
+    () => {
+      memoizedQueryParamsPathRef.current = path;
+      return queryParams ? {
+        ...queryParams,
+        ...relation ? {
+          filters: [
+            ...queryParams.filters || [],
+            { col: relation.foreign_key, opr: relation.type, value: convertId(relation.id) }
+          ]
+        } : {}
+      } : null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [queryParams, relation]
+  );
+  const queryParamsRef = useRef(memoizedQueryParams);
+  useEffect(() => {
+    queryParamsRef.current = memoizedQueryParams;
+  }, [memoizedQueryParams]);
+  const setQueryParamsCallback = useCallback(
+    (partialQueryParams) => setQueryParams((prev) => {
+      if (typeof partialQueryParams === "function") {
+        partialQueryParams = partialQueryParams(prev);
+      }
+      if (!prev) {
+        return createQueryParams(null, partialQueryParams);
+      }
+      const newQueryParams = createQueryParams({ ...prev }, partialQueryParams);
+      if (partialQueryParams) {
+        if ((partialQueryParams.filters || partialQueryParams.order_column || partialQueryParams.order_direction) && !partialQueryParams.page) {
+          newQueryParams.page = 0;
+        }
+        if (streamingMode) {
+          if (partialQueryParams.page && partialQueryParams.page !== prev.page && !partialQueryParams.streaming) {
+            throw new Error("You cannot change page in streaming mode, use streaming.fetch() instead");
+          }
+          if (partialQueryParams.page_size && partialQueryParams.page_size !== prev.page_size) {
+            throw new Error("You cannot change page size in streaming mode, use streaming.fetch() instead");
+          }
+        }
+      }
+      return newQueryParams;
+    }),
+    [streamingMode]
+  );
+  const [error, setError] = useState(null);
+  const memoizedError = useMemo(() => error, [error]);
+  const resetError = useCallback(() => setError(null), []);
+  const {
+    data: info,
+    isFetching: infoLoading,
+    refetch: infoRefetch,
+    error: infoError
+  } = useQuery({
+    queryKey: [`info`, path],
+    queryFn: ({ signal }) => getInfo(urlJoin(path, "_info"), signal).then((data2) => ({ ...convertInfo(data2), path })),
+    placeholderData: clearInfoOnRefetch ? null : keepPreviousData,
+    enabled: fetchInfo,
+    retry: false,
+    refetchOnMount: false,
+    refetchOnReconnect: false,
+    refetchOnWindowFocus: false,
+    ...infoQueryProps
+  });
+  const {
+    data,
+    isFetching: dataLoading,
+    refetch: dataRefetch,
+    error: dataError
+  } = useQuery({
+    queryKey: [`data`, memoizedQueryParamsPathRef.current, JSON.stringify(memoizedQueryParams)],
+    queryFn: ({ signal }) => memoizedQueryParams ? getItems(urlJoin(memoizedQueryParamsPathRef.current, "/"), memoizedQueryParams, signal).then((data2) => ({
+      ...data2,
+      result: data2.result.map((item, index) => ({ ...item, id: data2.ids[index] })),
+      path: memoizedQueryParamsPathRef.current
+    })) : null,
+    placeholderData: clearDataOnRefetch ? null : keepPreviousData,
+    retry: false,
+    ...dataQueryProps
+  });
+  useEffect(() => {
+    if (infoError) {
+      setError({ message: `Couldn't fetch info`, originalError: infoError });
+      return;
+    }
+    if (dataError) {
+      setError({ message: `Couldn't fetch list`, originalError: dataError });
+      return;
+    }
+    resetError();
+  }, [infoError, dataError, resetError]);
+  const loading = useMemo(() => infoLoading || dataLoading, [infoLoading, dataLoading]);
+  useDidUpdate(() => {
+    if (!resetQueryParamsOnPathChange) {
+      return;
+    }
+    const newQueryParams = createQueryParams(null, initialQueryParams);
+    if (queryParams == null ? void 0 : queryParams.page_size) {
+      newQueryParams.page_size = queryParams.page_size;
+    }
+    setQueryParams({ ...newQueryParams });
+  }, [path]);
+  const getEntry = useCallback(
+    async (id) => {
+      try {
+        const response = await getItem(pathRef.current, convertId(id));
+        resetError();
+        return response;
+      } catch (error2) {
+        setError({ message: `Couldn't fetch item with id ${id}`, originalError: error2 });
+        if (throwOnError) {
+          throw error2;
+        }
+      }
+    },
+    [resetError, throwOnError]
+  );
+  const addEntry = useCallback(
+    async (item) => {
+      try {
+        const response = await createItem(pathRef.current, item);
+        resetError();
+        return response;
+      } catch (error2) {
+        setError({ message: `Couldn't add item`, originalError: error2 });
+        if (throwOnError) {
+          throw error2;
+        }
+      }
+    },
+    [resetError, throwOnError]
+  );
+  const updateEntry = useCallback(
+    async (id, item) => {
+      try {
+        const response = await updateItem(pathRef.current, convertId(id), item);
+        resetError();
+        return response;
+      } catch (error2) {
+        setError({ message: `Couldn't update item with id ${id}`, originalError: error2 });
+        if (throwOnError) {
+          throw error2;
+        }
+      }
+    },
+    [resetError, throwOnError]
+  );
+  const deleteEntry = useCallback(
+    async (id) => {
+      try {
+        const response = await deleteItem(pathRef.current, convertId(id));
+        resetError();
+        return response;
+      } catch (error2) {
+        setError({ message: `Couldn't delete item with id ${id}`, originalError: error2 });
+        if (throwOnError) {
+          throw error2;
+        }
+      }
+    },
+    [resetError, throwOnError]
+  );
+  const download = useCallback(
+    async (label, { export_mode, delimiter, quotechar } = {}) => {
+      try {
+        await downloadItems(pathRef.current, queryParamsRef.current, { label, export_mode, delimiter, quotechar });
+        resetError();
+      } catch (error2) {
+        setError({ message: `Couldn't download`, originalError: error2 });
+        if (throwOnError) {
+          throw error2;
+        }
+      }
+    },
+    [resetError, throwOnError]
+  );
+  const upload = useCallback(
+    async (file, { delimiter, quotechar } = {}) => {
+      try {
+        const response = await uploadItems(pathRef.current, file, { delimiter, quotechar });
+        resetError();
+        return response;
+      } catch (error2) {
+        setError({ message: `Couldn't upload`, originalError: error2 });
+        if (throwOnError) {
+          throw error2;
+        }
+      }
+    },
+    [resetError, throwOnError]
+  );
+  const [streaming, setStreaming] = useSetState({
+    data: {},
+    isEnd: false,
+    fetch: () => null
+  });
+  useEffect(() => {
+    if (!streamingMode) {
+      return;
+    }
+    setStreaming({
+      fetch: () => setQueryParamsCallback({ page: 0, streaming: true })
+    });
+  }, [setQueryParamsCallback, setStreaming, streamingMode]);
+  useEffect(() => {
+    if (!streamingMode) {
+      return;
+    }
+    if (!data) {
+      return;
+    }
+    setStreaming((prev) => {
+      let latestPage = Object.keys(prev.data).length;
+      const newStreaming = { isEnd: false };
+      if (memoizedQueryParams.page < latestPage) {
+        latestPage = memoizedQueryParams.page;
+        newStreaming.data = { [memoizedQueryParams.page]: data.result };
+      } else {
+        newStreaming.data = { ...prev.data, [memoizedQueryParams.page]: data.result };
+      }
+      if (data.result.length < memoizedQueryParams.page_size) {
+        newStreaming.isEnd = true;
+        newStreaming.fetch = () => null;
+      } else {
+        newStreaming.fetch = () => setQueryParamsCallback({ page: latestPage + 1, streaming: true });
+      }
+      return newStreaming;
+    });
+  }, [data, setQueryParamsCallback, setStreaming, streamingMode]);
+  const specialKey = useMemo(() => {
+    const specialKey2 = {
+      all: "all",
+      actions: "actions"
+    };
+    data == null ? void 0 : data.list_columns.forEach((key) => {
+      if (specialKey2[key]) {
+        specialKey2[key] = `_${key}`;
+      }
+    });
+    return specialKey2;
+  }, [data == null ? void 0 : data.list_columns]);
+  const refetch = useCallback(
+    () => queryParamsRef.current ? dataRefetch() : setQueryParamsCallback(),
+    [dataRefetch, setQueryParamsCallback]
+  );
+  return {
+    path,
+    data,
+    info,
+    queryParams: memoizedQueryParams,
+    loading,
+    error: memoizedError,
+    streaming,
+    specialKey,
+    setQueryParams: setQueryParamsCallback,
+    refetch,
+    refetchInfo: infoRefetch,
+    getEntry,
+    addEntry,
+    updateEntry,
+    deleteEntry,
+    download,
+    upload,
+    resetError
+  };
+}
+export {
+  useFabProvideApi
+};

package/dist/core/esm/fab-react-toolkit-patch/api/hooks/useProvideBulk.mjs

@@ -0,0 +1,30 @@
+import { useState, useCallback, useMemo } from "react";
+import { postBulk } from "../utils/bulkActions/postBulkAction.mjs";
+const useFabProvideBulk = ({ path }) => {
+  const [selectedIds, setSelectedIds] = useState([]);
+  const [error, setError] = useState();
+  const dispatchBulkActions = useCallback(
+    async (handler, data) => {
+      try {
+        if (data === void 0) {
+          data = selectedIds;
+        }
+        const response = await postBulk(path, handler, data);
+        setError(void 0);
+        return response;
+      } catch (error2) {
+        setError({ message: `Couldn't perform bulk action`, originalError: error2 });
+      }
+    },
+    [path, selectedIds]
+  );
+  const bulkActions = useMemo(() => ({ selectedIds, setSelectedIds }), [selectedIds, setSelectedIds]);
+  return {
+    bulkActions,
+    dispatchBulkActions,
+    error
+  };
+};
+export {
+  useFabProvideBulk
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/createItem.mjs

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

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/deleteItem.mjs

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

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/downloadItems.mjs

@@ -0,0 +1,41 @@
+import { createFetchParams, urlJoin } from "fastapi-rtk/utils";
+const downloadItems = async (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;
+  }
+  delete _queryParams.check_validity;
+  const { fetchPath, options } = createFetchParams({
+    path: urlJoin(path, "/download"),
+    method: "POST",
+    body: {
+      ..._queryParams,
+      queryParams
+    }
+  });
+  const response = await fetch(fetchPath, options);
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  }
+  const data = await response.blob();
+  const link = URL.createObjectURL(data);
+  const a = document.createElement("a");
+  a.href = link;
+  a.download = (label || _queryParams.label || path.split("/").pop()) + ".csv";
+  a.style.display = "none";
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+};
+export {
+  downloadItems
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/getInfo.mjs

@@ -0,0 +1,13 @@
+import { createFetchParams } from "fastapi-rtk/utils";
+import { parseResponse } from "./utils/parseResponse.mjs";
+const getInfo = async (path, signal) => {
+  const { fetchPath, options } = createFetchParams({
+    path,
+    method: "GET"
+  });
+  const response = await fetch(fetchPath, { signal, ...options });
+  return await parseResponse(response);
+};
+export {
+  getInfo
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/getItem.mjs

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

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/getItems.mjs

@@ -0,0 +1,10 @@
+import { createFetchParams } from "fastapi-rtk/utils";
+import { parseResponse } from "./utils/parseResponse.mjs";
+const getItems = async (path, queryParams, signal) => {
+  const { fetchPath, options } = createFetchParams({ path, method: "GET", queryParams: { q: queryParams } });
+  const response = await fetch(fetchPath, { signal, ...options });
+  return await parseResponse(response);
+};
+export {
+  getItems
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/updateItem.mjs

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

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/uploadItems.mjs

@@ -0,0 +1,27 @@
+import { createFetchParams, urlJoin } from "fastapi-rtk/utils";
+import { parseResponse } from "./utils/parseResponse.mjs";
+const uploadItems = async (path, file, { delimiter, quotechar } = {}) => {
+  const formData = new FormData();
+  formData.append("file", file);
+  const queryParams = {};
+  if (delimiter) {
+    queryParams.delimiter = delimiter;
+  }
+  if (quotechar) {
+    queryParams.quotechar = quotechar;
+  }
+  const { fetchPath, options } = createFetchParams({
+    path: urlJoin(path, "/upload"),
+    method: "POST",
+    queryParams
+  });
+  const response = await fetch(fetchPath, {
+    ...options,
+    headers: void 0,
+    body: formData
+  });
+  return await parseResponse(response);
+};
+export {
+  uploadItems
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/api/utils/parseResponse.mjs

@@ -0,0 +1,19 @@
+const parseResponse = async (response) => {
+  let newData = void 0;
+  const contentType = response.headers.get("content-type");
+  if (contentType && contentType.includes("application/json")) {
+    newData = await response.json();
+  } else {
+    newData = await response.text();
+  }
+  if (!response.ok) {
+    if (typeof newData === "object") {
+      throw new Error(typeof newData.message === "string" ? newData.message : JSON.stringify(newData, void 0, 2));
+    }
+    throw new Error(newData);
+  }
+  return newData;
+};
+export {
+  parseResponse
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/bulkActions/postBulkAction.mjs

@@ -0,0 +1,26 @@
+import { createFetchParams, urlJoin } from "fastapi-rtk/utils";
+const postBulk = async (path, handler, data) => {
+  const { fetchPath, options } = createFetchParams({
+    path: urlJoin(path, "/bulk", handler),
+    method: "POST",
+    body: data
+  });
+  const response = await fetch(fetchPath, options);
+  let newData = null;
+  const contentType = response.headers.get("content-type");
+  if (contentType && contentType.includes("application/json")) {
+    newData = await response.json();
+  } else {
+    newData = await response.text();
+  }
+  if (!response.ok) {
+    if (typeof newData === "object") {
+      throw new Error(typeof newData.message === "string" ? newData.message : JSON.stringify(newData, null, 2));
+    }
+    throw new Error(newData);
+  }
+  return newData;
+};
+export {
+  postBulk
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/convertId.mjs

@@ -0,0 +1,12 @@
+const convertId = (value) => {
+  if (value && typeof value === "object") {
+    if (Array.isArray(value)) {
+      return value.join(",");
+    }
+    return JSON.stringify(value);
+  }
+  return value;
+};
+export {
+  convertId
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/convertInfo.mjs

@@ -0,0 +1,20 @@
+import { getDefaultValues } from "./getDefaultValues.mjs";
+import { getValidationSchema } from "./getValidationSchema.mjs";
+const convertInfo = (info) => info ? {
+  ...info,
+  add: {
+    columns: info.add_columns,
+    title: info.add_title,
+    schema: getValidationSchema(info.add_columns),
+    defaultValues: getDefaultValues(info.add_columns)
+  },
+  edit: {
+    columns: info.edit_columns,
+    title: info.edit_title,
+    schema: getValidationSchema(info.edit_columns),
+    defaultValues: getDefaultValues(info.edit_columns)
+  }
+} : null;
+export {
+  convertInfo
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/createQueryParams.mjs

@@ -0,0 +1,18 @@
+const initialQueryParams = {
+  columns: [],
+  filters: [],
+  page: 0,
+  page_size: 25
+};
+function createQueryParams(currentQueryParams, partialQueryParams = {}) {
+  return Object.entries(partialQueryParams).reduce((acc, [key, value]) => {
+    if (value === null || value === void 0) {
+      delete acc[key];
+      return acc;
+    }
+    return { ...acc, [key]: value };
+  }, currentQueryParams || initialQueryParams);
+}
+export {
+  createQueryParams
+};

package/dist/core/esm/fab-react-toolkit-patch/api/utils/getDefaultValues.mjs

@@ -0,0 +1,28 @@
+const getDefaultValues = (columns) => {
+  const defaultValues = {};
+  for (const item of columns) {
+    switch (item.type) {
+      case "RelatedList":
+        defaultValues[item.name] = [];
+        break;
+      case "Boolean":
+        defaultValues[item.name] = "false";
+        break;
+      case "Date":
+      case "DateTime":
+      case "Integer":
+      case "Float":
+      case "Geometry":
+      case "Raw":
+      case "Related":
+        defaultValues[item.name] = void 0;
+        break;
+      default:
+        defaultValues[item.name] = "";
+    }
+  }
+  return defaultValues;
+};
+export {
+  getDefaultValues
+};