fastapi-rtk 0.1.12 → 0.1.14

package/dist/core/esm/Tables/NextGenDataGrid/hooks/useToolbarAlertBanner/FASTAPI_RTK_ToolbarAlertBanner.mjs

@@ -0,0 +1,113 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { parseFromValuesOrFunc, getValueOrDefault } from "fastapi-rtk/utils";
+import { Flex, Button, Group, Badge, ActionIcon, Stack } from "@mantine/core";
+import { clsx } from "../../../../../../external/esm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs";
+import { getMRT_SelectAllHandler, MRT_SelectCheckbox } from "../../../../../../external/esm/mantine-react-table@2.0.0-beta.9_@mantine_core@7.17.7_@mantine_dates@7.17.7_@mantine_hooks@7._dm3meh6s7t7wwl37at3cedg6gm/node_modules/mantine-react-table/dist/index.esm.mjs";
+import { useMemo, Fragment } from "react";
+import classes from "./FASTAPI_RTK_ToolbarAlertBanner.module.css.mjs";
+const FASTAPI_RTK_ToolbarAlertBanner = ({ alertBanner, table, ...rest }) => {
+  var _a, _b;
+  const {
+    getFilteredSelectedRowModel,
+    getPrePaginationRowModel,
+    getState,
+    resetRowSelection,
+    options: {
+      enableRowSelection,
+      enableSelectAll,
+      icons: { IconX },
+      localization,
+      mantineToolbarAlertBannerBadgeProps,
+      mantineToolbarAlertBannerProps,
+      manualPagination,
+      positionToolbarAlertBanner,
+      rowCount
+    }
+  } = table;
+  const { density, grouping, rowSelection } = getState();
+  const { left, right, renderToolbarAlertBannerContent, wrapperProps } = alertBanner ?? {};
+  const { flex, group, stack } = wrapperProps ?? {};
+  const alertProps = {
+    ...parseFromValuesOrFunc(mantineToolbarAlertBannerProps, {
+      table
+    }),
+    ...rest
+  };
+  const badgeProps = parseFromValuesOrFunc(mantineToolbarAlertBannerBadgeProps, { table });
+  const totalRowCount = rowCount ?? getPrePaginationRowModel().flatRows.length;
+  const selectedRowCount = useMemo(
+    () => manualPagination ? Object.values(rowSelection).filter(Boolean).length : getFilteredSelectedRowModel().rows.length,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [rowSelection, totalRowCount, manualPagination]
+  );
+  const selectedAlert = selectedRowCount ? /* @__PURE__ */ jsxs(Flex, { align: "center", gap: "sm", children: [
+    (_b = (_a = localization.selectedCountOfRowCountRowsSelected) == null ? void 0 : _a.replace("{selectedCount}", selectedRowCount.toString())) == null ? void 0 : _b.replace("{rowCount}", totalRowCount.toString()),
+    /* @__PURE__ */ jsx(Button, { onClick: resetRowSelection, size: "compact-xs", variant: "subtle", children: localization.clearSelection }),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        onClick: (event) => getMRT_SelectAllHandler({ table })(event, false, true),
+        size: "compact-xs",
+        variant: "subtle",
+        children: localization.clearSelectionOnThisPage ?? "Clear selection on this page"
+      }
+    )
+  ] }) : null;
+  const groupedAlert = grouping.length > 0 ? /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
+    localization.groupedBy,
+    grouping.map((columnId, index) => /* @__PURE__ */ jsxs(Fragment, { children: [
+      index > 0 ? localization.thenBy : "",
+      /* @__PURE__ */ jsxs(
+        Badge,
+        {
+          className: "alert-badge",
+          rightSection: /* @__PURE__ */ jsx(
+            ActionIcon,
+            {
+              color: "white",
+              onClick: () => table.getColumn(columnId).toggleGrouping(),
+              size: "xs",
+              variant: "subtle",
+              children: /* @__PURE__ */ jsx(IconX, { style: { transform: "scale(0.8)" } })
+            }
+          ),
+          variant: "filled",
+          ...badgeProps,
+          children: [
+            table.getColumn(columnId).columnDef.header,
+            " "
+          ]
+        }
+      )
+    ] }, `${index}-${columnId}`))
+  ] }) : null;
+  return /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      className: clsx(
+        classes["toolbar-alert"],
+        positionToolbarAlertBanner === "head-overlay" && classes["head-overlay"],
+        density
+      ),
+      ...flex,
+      children: [
+        enableRowSelection && enableSelectAll && positionToolbarAlertBanner === "head-overlay" && /* @__PURE__ */ jsx(MRT_SelectCheckbox, { table }),
+        /* @__PURE__ */ jsxs(Group, { align: "flex-start", gap: "xs", ...group, children: [
+          parseFromValuesOrFunc(left, { table }),
+          getValueOrDefault(
+            parseFromValuesOrFunc(renderToolbarAlertBannerContent, { selectedAlert, groupedAlert, table }),
+            /* @__PURE__ */ jsxs(Stack, { gap: "xs", ...stack, children: [
+              alertProps == null ? void 0 : alertProps.children,
+              selectedAlert,
+              groupedAlert
+            ] })
+          ),
+          parseFromValuesOrFunc(right, { table })
+        ] })
+      ]
+    }
+  );
+};
+export {
+  FASTAPI_RTK_ToolbarAlertBanner
+};

package/dist/core/esm/Tables/NextGenDataGrid/hooks/useToolbarAlertBanner/FASTAPI_RTK_ToolbarAlertBanner.module.css.mjs

@@ -0,0 +1,7 @@
+const classes = {
+  "toolbar-alert": "_toolbar-alert_bw71q_25",
+  "head-overlay": "_head-overlay_bw71q_28"
+};
+export {
+  classes as default
+};

package/dist/core/esm/Tables/NextGenDataGrid/hooks/useToolbarAlertBanner/useToolbarAlertBanner.mjs

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { FASTAPI_RTK_ToolbarAlertBanner } from "./FASTAPI_RTK_ToolbarAlertBanner.mjs";
+function useToolbarAlertBanner(toolbar) {
+  const { alertBanner } = toolbar;
+  return {
+    renderToolbarAlertBannerContent: ({ table }) => /* @__PURE__ */ jsx(FASTAPI_RTK_ToolbarAlertBanner, { alertBanner, table })
+  };
+}
+export {
+  useToolbarAlertBanner
+};

package/dist/core/esm/Tables/NextGenDataGrid/utils.mjs

@@ -0,0 +1,23 @@
+import { deepMerge } from "fastapi-rtk/utils";
+const getProps = (propsObj = {}, ...keys) => keys.reduce((acc, key) => deepMerge(acc, propsObj[key]), {});
+const fromFilterToFilterFn = (columnId, operator, filterPrefix = false) => {
+  let word = "";
+  if (filterPrefix) {
+    word += "filter";
+  }
+  const firstLetter = filterPrefix ? columnId[0].toUpperCase() : columnId[0].toLowerCase();
+  word += firstLetter + columnId.slice(1);
+  return `${word}*${operator}`;
+};
+const fromFilterFnToFilter = (filterKey = "") => {
+  if (filterKey.startsWith("filter")) {
+    filterKey = filterKey.slice(6);
+  }
+  const [col = "", operator = ""] = filterKey.split("*");
+  return { col, operator };
+};
+export {
+  fromFilterFnToFilter,
+  fromFilterToFilterFn,
+  getProps
+};

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

@@ -0,0 +1,51 @@
+import { jsx } from "react/jsx-runtime";
+import { urlJoin } from "fastapi-rtk/utils";
+import { useProxy, createProxy } from "fastapi-rtk/zustand";
+import { useState } from "react";
+import { useInfo } from "../../hooks/auth/useInfo.mjs";
+import { ApiContext } from "./Contexts/ApiContext.mjs";
+import { BulkActionsContext } from "./Contexts/BulkActionsContext.mjs";
+import { FormContextAdd, FormContextEdit } from "./Contexts/FormContext.mjs";
+import { useProvideApi } from "./hooks/useProvideApi.mjs";
+import { useProvideBulk } from "./hooks/useProvideBulk.mjs";
+import { useProvideForm } from "./hooks/useProvideForm.mjs";
+function ApiProvider({
+  resource_name = "",
+  initialQueryParams,
+  relation,
+  fetchInfo,
+  clearInfoOnRefetch,
+  clearDataOnRefetch,
+  resetQueryParamsOnPathChange,
+  infoQueryProps,
+  dataQueryProps,
+  throwOnError,
+  streaming,
+  children
+}) {
+  const { baseUrl } = useInfo();
+  const api = useProvideApi({
+    path: urlJoin(baseUrl, resource_name),
+    initialQueryParams,
+    relation,
+    fetchInfo,
+    clearInfoOnRefetch,
+    clearDataOnRefetch,
+    resetQueryParamsOnPathChange,
+    infoQueryProps,
+    dataQueryProps,
+    throwOnError,
+    streaming
+  });
+  const apiProxy = useProxy(api);
+  const bulkActions = useProvideBulk(apiProxy);
+  const bulkActionsProxy = useProxy(bulkActions);
+  const formAdd = useProvideForm();
+  const [formAddProxy] = useState(() => createProxy(formAdd));
+  const formEdit = useProvideForm();
+  const [formEditProxy] = useState(() => createProxy(formEdit));
+  return /* @__PURE__ */ jsx(ApiContext.Provider, { value: apiProxy, children: /* @__PURE__ */ jsx(BulkActionsContext.Provider, { value: bulkActionsProxy, children: /* @__PURE__ */ jsx(FormContextAdd.Provider, { value: formAddProxy, children: /* @__PURE__ */ jsx(FormContextEdit.Provider, { value: formEditProxy, children }) }) }) });
+}
+export {
+  ApiProvider
+};

package/dist/core/esm/Wrappers/ApiProvider/Contexts/ApiContext.mjs

@@ -0,0 +1,42 @@
+import { createContext } from "react";
+const ApiContext = createContext({
+  path: "",
+  /**
+   * @type {{count: number, description_columns: Record<string, string>, ids: int[] | string[], label_columns: Record<string, string>, list_columns: string[], list_title: string, order_columns: string[], result: Record<string, any>[], path: string} | null}
+   */
+  data: null,
+  /**
+   * @type {{add_columns: Record<string, ColumnInfo>[], add_title: string, add_schema: Record<string, any>, add_uischema: Record<string, any>, edit_columns: Record<string, ColumnInfo>[], edit_title: string, edit_schema: Record<string, any>, edit_uischema: Record<string, any>, filter_options: Record<string, any>, filters: Record<string, Filter>, permissions: string[], relations: string[] | null, path: string} | null}
+   */
+  info: null,
+  /**
+   * @type {{columns: string[], filters: {col: string, opr: string, value: Any}[], order_column: string | undefined, order_direction: string | undefined, page: int, page_size: int, global_filter: string | undefined} | null}
+   */
+  queryParams: null,
+  loading: false,
+  /**
+   * @type {{message: string, originalError: Error} | null}
+   */
+  error: null,
+  /**
+   * @type {{data: Record<string, Record<string, any>[]>, isEnd: boolean, fetch: () => void}}
+   */
+  streaming: null,
+  /**
+   * @type {{all: string, actions: string}}
+   */
+  specialKey: null,
+  setQueryParams: (partialQueryParams) => null,
+  refetch: async (options) => null,
+  refetchInfo: async (options) => null,
+  getEntry: async (id) => ({}),
+  addEntry: async (item) => ({}),
+  updateEntry: async (id, item) => ({}),
+  deleteEntry: async (id) => ({}),
+  download: async (label, { export_mode, delimiter, quotechar } = {}) => null,
+  upload: async (file, { delimiter, quotechar } = {}) => ({}),
+  resetError: () => null
+});
+export {
+  ApiContext
+};

package/dist/core/esm/Wrappers/ApiProvider/Contexts/BulkActionsContext.mjs

@@ -0,0 +1,13 @@
+import { createContext } from "react";
+const BulkActionsContext = createContext({
+  bulkActions: { selectedIds: [], setSelectedIds: () => void 0 },
+  dispatchBulkActions: async (handler, data) => {
+  },
+  /**
+   * @type {{message: string, originalError: Error} | null}
+   */
+  error: null
+});
+export {
+  BulkActionsContext
+};

package/dist/core/esm/Wrappers/ApiProvider/Contexts/FormContext.mjs

@@ -0,0 +1,28 @@
+import { createContext } from "react";
+const stubContext = {
+  opened: false,
+  setOpened: () => {
+    throw new Error("setOpened must be defined in a provider");
+  },
+  view: 0,
+  setView: () => {
+    throw new Error("setView must be defined in a provider");
+  },
+  state: void 0,
+  setState: () => {
+    throw new Error("setState must be defined in a provider");
+  },
+  reset: () => {
+    throw new Error("reset must be defined in a provider");
+  },
+  item: void 0,
+  setItem: () => {
+    throw new Error("setItem must be defined in a provider");
+  }
+};
+const FormContextAdd = createContext(stubContext);
+const FormContextEdit = createContext(stubContext);
+export {
+  FormContextAdd,
+  FormContextEdit
+};

package/dist/core/esm/Wrappers/ApiProvider/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.75.0/node_modules/@tanstack/query-core/build/modern/utils.mjs";
+import { useQuery } from "../../../../../external/esm/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@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 useProvideApi({
+  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 {
+  useProvideApi
+};

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

@@ -0,0 +1,30 @@
+import { useState, useCallback, useMemo } from "react";
+import { postBulk } from "../utils/bulkActions/postBulkAction.mjs";
+const useProvideBulk = ({ 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 {
+  useProvideBulk
+};

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

@@ -0,0 +1,22 @@
+import { initialState, VIEW_MODE } from "fastapi-rtk/constants";
+import { useState } from "react";
+import { create } from "../../../../../external/esm/zustand@5.0.4_@types_react@18.3.20_react@18.3.1/node_modules/zustand/esm/react.mjs";
+const useProvideForm = () => {
+  const [storeAdd] = useState(
+    () => create((set) => ({
+      opened: false,
+      setOpened: (newOpened) => set({ opened: newOpened }),
+      view: VIEW_MODE.NORMAL,
+      setView: (newView) => set({ view: newView }),
+      state: initialState,
+      setState: (newState) => set({ state: newState }),
+      reset: () => set({ state: initialState }),
+      item: void 0,
+      setItem: (newItem) => set({ item: newItem })
+    }))
+  );
+  return storeAdd;
+};
+export {
+  useProvideForm
+};

package/dist/core/esm/Wrappers/ApiProvider/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/Wrappers/ApiProvider/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
+};