fastapi-rtk 0.1.12 → 0.1.14

package/dist/core/cjs/Tables/NextGenDataGrid/hooks/useToolbarAlertBanner/FASTAPI_RTK_ToolbarAlertBanner.cjs

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const utils = require("fastapi-rtk/utils");
+const core = require("@mantine/core");
+const clsx = require("../../../../../../external/cjs/clsx@2.1.1/node_modules/clsx/dist/clsx.cjs");
+const index_esm = require("../../../../../../external/cjs/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.cjs");
+const React = require("react");
+const FASTAPI_RTK_ToolbarAlertBanner_module = require("./FASTAPI_RTK_ToolbarAlertBanner.module.css.cjs");
+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 = {
+    ...utils.parseFromValuesOrFunc(mantineToolbarAlertBannerProps, {
+      table
+    }),
+    ...rest
+  };
+  const badgeProps = utils.parseFromValuesOrFunc(mantineToolbarAlertBannerBadgeProps, { table });
+  const totalRowCount = rowCount ?? getPrePaginationRowModel().flatRows.length;
+  const selectedRowCount = React.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__ */ jsxRuntime.jsxs(core.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__ */ jsxRuntime.jsx(core.Button, { onClick: resetRowSelection, size: "compact-xs", variant: "subtle", children: localization.clearSelection }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      core.Button,
+      {
+        onClick: (event) => index_esm.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__ */ jsxRuntime.jsxs(core.Group, { gap: "xs", children: [
+    localization.groupedBy,
+    grouping.map((columnId, index) => /* @__PURE__ */ jsxRuntime.jsxs(React.Fragment, { children: [
+      index > 0 ? localization.thenBy : "",
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        core.Badge,
+        {
+          className: "alert-badge",
+          rightSection: /* @__PURE__ */ jsxRuntime.jsx(
+            core.ActionIcon,
+            {
+              color: "white",
+              onClick: () => table.getColumn(columnId).toggleGrouping(),
+              size: "xs",
+              variant: "subtle",
+              children: /* @__PURE__ */ jsxRuntime.jsx(IconX, { style: { transform: "scale(0.8)" } })
+            }
+          ),
+          variant: "filled",
+          ...badgeProps,
+          children: [
+            table.getColumn(columnId).columnDef.header,
+            " "
+          ]
+        }
+      )
+    ] }, `${index}-${columnId}`))
+  ] }) : null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    core.Flex,
+    {
+      className: clsx.clsx(
+        FASTAPI_RTK_ToolbarAlertBanner_module["toolbar-alert"],
+        positionToolbarAlertBanner === "head-overlay" && FASTAPI_RTK_ToolbarAlertBanner_module["head-overlay"],
+        density
+      ),
+      ...flex,
+      children: [
+        enableRowSelection && enableSelectAll && positionToolbarAlertBanner === "head-overlay" && /* @__PURE__ */ jsxRuntime.jsx(index_esm.MRT_SelectCheckbox, { table }),
+        /* @__PURE__ */ jsxRuntime.jsxs(core.Group, { align: "flex-start", gap: "xs", ...group, children: [
+          utils.parseFromValuesOrFunc(left, { table }),
+          utils.getValueOrDefault(
+            utils.parseFromValuesOrFunc(renderToolbarAlertBannerContent, { selectedAlert, groupedAlert, table }),
+            /* @__PURE__ */ jsxRuntime.jsxs(core.Stack, { gap: "xs", ...stack, children: [
+              alertProps == null ? void 0 : alertProps.children,
+              selectedAlert,
+              groupedAlert
+            ] })
+          ),
+          utils.parseFromValuesOrFunc(right, { table })
+        ] })
+      ]
+    }
+  );
+};
+exports.FASTAPI_RTK_ToolbarAlertBanner = FASTAPI_RTK_ToolbarAlertBanner;

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

@@ -0,0 +1,6 @@
+"use strict";
+const classes = {
+  "toolbar-alert": "_toolbar-alert_bw71q_25",
+  "head-overlay": "_head-overlay_bw71q_28"
+};
+module.exports = classes;

package/dist/core/cjs/Tables/NextGenDataGrid/hooks/useToolbarAlertBanner/useToolbarAlertBanner.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const FASTAPI_RTK_ToolbarAlertBanner = require("./FASTAPI_RTK_ToolbarAlertBanner.cjs");
+function useToolbarAlertBanner(toolbar) {
+  const { alertBanner } = toolbar;
+  return {
+    renderToolbarAlertBannerContent: ({ table }) => /* @__PURE__ */ jsxRuntime.jsx(FASTAPI_RTK_ToolbarAlertBanner.FASTAPI_RTK_ToolbarAlertBanner, { alertBanner, table })
+  };
+}
+exports.useToolbarAlertBanner = useToolbarAlertBanner;

package/dist/core/cjs/Tables/NextGenDataGrid/utils.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("fastapi-rtk/utils");
+const getProps = (propsObj = {}, ...keys) => keys.reduce((acc, key) => utils.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 };
+};
+exports.fromFilterFnToFilter = fromFilterFnToFilter;
+exports.fromFilterToFilterFn = fromFilterToFilterFn;
+exports.getProps = getProps;

package/dist/core/cjs/Wrappers/ApiProvider/ApiProvider.cjs

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

package/dist/core/cjs/Wrappers/ApiProvider/Contexts/ApiContext.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const ApiContext = React.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
+});
+exports.ApiContext = ApiContext;

package/dist/core/cjs/Wrappers/ApiProvider/Contexts/BulkActionsContext.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const BulkActionsContext = React.createContext({
+  bulkActions: { selectedIds: [], setSelectedIds: () => void 0 },
+  dispatchBulkActions: async (handler, data) => {
+  },
+  /**
+   * @type {{message: string, originalError: Error} | null}
+   */
+  error: null
+});
+exports.BulkActionsContext = BulkActionsContext;

package/dist/core/cjs/Wrappers/ApiProvider/Contexts/FormContext.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("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 = React.createContext(stubContext);
+const FormContextEdit = React.createContext(stubContext);
+exports.FormContextAdd = FormContextAdd;
+exports.FormContextEdit = FormContextEdit;

package/dist/core/cjs/Wrappers/ApiProvider/hooks/useProvideApi.cjs

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const utils$1 = require("fastapi-rtk/utils");
+const hooks = require("@mantine/hooks");
+const utils = require("../../../../../external/cjs/@tanstack_query-core@5.75.0/node_modules/@tanstack/query-core/build/modern/utils.cjs");
+const useQuery = require("../../../../../external/cjs/@tanstack_react-query@5.75.1_react@18.3.1/node_modules/@tanstack/react-query/build/modern/useQuery.cjs");
+const createItem = require("../utils/api/createItem.cjs");
+const deleteItem = require("../utils/api/deleteItem.cjs");
+const downloadItems = require("../utils/api/downloadItems.cjs");
+const getInfo = require("../utils/api/getInfo.cjs");
+const getItem = require("../utils/api/getItem.cjs");
+const getItems = require("../utils/api/getItems.cjs");
+const updateItem = require("../utils/api/updateItem.cjs");
+const uploadItems = require("../utils/api/uploadItems.cjs");
+const convertId = require("../utils/convertId.cjs");
+const convertInfo = require("../utils/convertInfo.cjs");
+const createQueryParams = require("../utils/createQueryParams.cjs");
+function useProvideApi({
+  path,
+  initialQueryParams,
+  relation,
+  fetchInfo = true,
+  clearInfoOnRefetch = false,
+  clearDataOnRefetch = false,
+  resetQueryParamsOnPathChange = true,
+  infoQueryProps,
+  dataQueryProps,
+  throwOnError = false,
+  streaming: streamingMode = false
+}) {
+  const [queryParams, setQueryParams] = React.useState(
+    initialQueryParams ? createQueryParams.createQueryParams(null, initialQueryParams) : null
+  );
+  const pathRef = React.useRef(path);
+  React.useEffect(() => {
+    pathRef.current = path;
+  }, [path]);
+  const memoizedQueryParamsPathRef = React.useRef(path);
+  const memoizedQueryParams = React.useMemo(
+    () => {
+      memoizedQueryParamsPathRef.current = path;
+      return queryParams ? {
+        ...queryParams,
+        ...relation ? {
+          filters: [
+            ...queryParams.filters || [],
+            { col: relation.foreign_key, opr: relation.type, value: convertId.convertId(relation.id) }
+          ]
+        } : {}
+      } : null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [queryParams, relation]
+  );
+  const queryParamsRef = React.useRef(memoizedQueryParams);
+  React.useEffect(() => {
+    queryParamsRef.current = memoizedQueryParams;
+  }, [memoizedQueryParams]);
+  const setQueryParamsCallback = React.useCallback(
+    (partialQueryParams) => setQueryParams((prev) => {
+      if (typeof partialQueryParams === "function") {
+        partialQueryParams = partialQueryParams(prev);
+      }
+      if (!prev) {
+        return createQueryParams.createQueryParams(null, partialQueryParams);
+      }
+      const newQueryParams = createQueryParams.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] = React.useState(null);
+  const memoizedError = React.useMemo(() => error, [error]);
+  const resetError = React.useCallback(() => setError(null), []);
+  const {
+    data: info,
+    isFetching: infoLoading,
+    refetch: infoRefetch,
+    error: infoError
+  } = useQuery.useQuery({
+    queryKey: [`info`, path],
+    queryFn: ({ signal }) => getInfo.getInfo(utils$1.urlJoin(path, "_info"), signal).then((data2) => ({ ...convertInfo.convertInfo(data2), path })),
+    placeholderData: clearInfoOnRefetch ? null : utils.keepPreviousData,
+    enabled: fetchInfo,
+    retry: false,
+    refetchOnMount: false,
+    refetchOnReconnect: false,
+    refetchOnWindowFocus: false,
+    ...infoQueryProps
+  });
+  const {
+    data,
+    isFetching: dataLoading,
+    refetch: dataRefetch,
+    error: dataError
+  } = useQuery.useQuery({
+    queryKey: [`data`, memoizedQueryParamsPathRef.current, JSON.stringify(memoizedQueryParams)],
+    queryFn: ({ signal }) => memoizedQueryParams ? getItems.getItems(utils$1.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 : utils.keepPreviousData,
+    retry: false,
+    ...dataQueryProps
+  });
+  React.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 = React.useMemo(() => infoLoading || dataLoading, [infoLoading, dataLoading]);
+  hooks.useDidUpdate(() => {
+    if (!resetQueryParamsOnPathChange) {
+      return;
+    }
+    const newQueryParams = createQueryParams.createQueryParams(null, initialQueryParams);
+    if (queryParams == null ? void 0 : queryParams.page_size) {
+      newQueryParams.page_size = queryParams.page_size;
+    }
+    setQueryParams({ ...newQueryParams });
+  }, [path]);
+  const getEntry = React.useCallback(
+    async (id) => {
+      try {
+        const response = await getItem.getItem(pathRef.current, convertId.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 = React.useCallback(
+    async (item) => {
+      try {
+        const response = await createItem.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 = React.useCallback(
+    async (id, item) => {
+      try {
+        const response = await updateItem.updateItem(pathRef.current, convertId.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 = React.useCallback(
+    async (id) => {
+      try {
+        const response = await deleteItem.deleteItem(pathRef.current, convertId.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 = React.useCallback(
+    async (label, { export_mode, delimiter, quotechar } = {}) => {
+      try {
+        await downloadItems.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 = React.useCallback(
+    async (file, { delimiter, quotechar } = {}) => {
+      try {
+        const response = await uploadItems.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] = hooks.useSetState({
+    data: {},
+    isEnd: false,
+    fetch: () => null
+  });
+  React.useEffect(() => {
+    if (!streamingMode) {
+      return;
+    }
+    setStreaming({
+      fetch: () => setQueryParamsCallback({ page: 0, streaming: true })
+    });
+  }, [setQueryParamsCallback, setStreaming, streamingMode]);
+  React.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 = React.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 = React.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
+  };
+}
+exports.useProvideApi = useProvideApi;

package/dist/core/cjs/Wrappers/ApiProvider/hooks/useProvideBulk.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const postBulkAction = require("../utils/bulkActions/postBulkAction.cjs");
+const useProvideBulk = ({ path }) => {
+  const [selectedIds, setSelectedIds] = React.useState([]);
+  const [error, setError] = React.useState();
+  const dispatchBulkActions = React.useCallback(
+    async (handler, data) => {
+      try {
+        if (data === void 0) {
+          data = selectedIds;
+        }
+        const response = await postBulkAction.postBulk(path, handler, data);
+        setError(void 0);
+        return response;
+      } catch (error2) {
+        setError({ message: `Couldn't perform bulk action`, originalError: error2 });
+      }
+    },
+    [path, selectedIds]
+  );
+  const bulkActions = React.useMemo(() => ({ selectedIds, setSelectedIds }), [selectedIds, setSelectedIds]);
+  return {
+    bulkActions,
+    dispatchBulkActions,
+    error
+  };
+};
+exports.useProvideBulk = useProvideBulk;

package/dist/core/cjs/Wrappers/ApiProvider/hooks/useProvideForm.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const constants = require("fastapi-rtk/constants");
+const React = require("react");
+const react = require("../../../../../external/cjs/zustand@5.0.4_@types_react@18.3.20_react@18.3.1/node_modules/zustand/esm/react.cjs");
+const useProvideForm = () => {
+  const [storeAdd] = React.useState(
+    () => react.create((set) => ({
+      opened: false,
+      setOpened: (newOpened) => set({ opened: newOpened }),
+      view: constants.VIEW_MODE.NORMAL,
+      setView: (newView) => set({ view: newView }),
+      state: constants.initialState,
+      setState: (newState) => set({ state: newState }),
+      reset: () => set({ state: constants.initialState }),
+      item: void 0,
+      setItem: (newItem) => set({ item: newItem })
+    }))
+  );
+  return storeAdd;
+};
+exports.useProvideForm = useProvideForm;

package/dist/core/cjs/Wrappers/ApiProvider/utils/api/createItem.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("fastapi-rtk/utils");
+const parseResponse = require("./utils/parseResponse.cjs");
+const createItem = async (path, data) => {
+  const { fetchPath, options } = utils.createFetchParams({
+    path: utils.urlJoin(path, "/"),
+    method: "POST",
+    body: data
+  });
+  const response = await fetch(fetchPath, options);
+  return await parseResponse.parseResponse(response);
+};
+exports.createItem = createItem;