fastapi-rtk 0.1.12 → 0.1.14

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

@@ -0,0 +1,134 @@
+import { jsx } from "react/jsx-runtime";
+import { getValue, parseFromValuesOrFunc } from "fastapi-rtk/utils";
+import { useSetState } from "@mantine/hooks";
+import { useMemo, useEffect } from "react";
+import { useApi } from "../../../../hooks/api/useApi.mjs";
+import { useAuth } from "../../../../hooks/auth/useAuth.mjs";
+import { FallbackWrapper } from "../../FallbackWrapper.mjs";
+import { getProps, fromFilterToFilterFn } from "../../utils.mjs";
+import { ColumnHeaderFilter } from "./ColumnHeaderFilter/ColumnHeaderFilter.mjs";
+import { MultiLineHighlight } from "./MultiLineHighlight.mjs";
+function useColumns(columnProps, header, body, textFilterSeparator) {
+  const { path, info, data, specialKey } = useApi();
+  const api = useApi();
+  const auth = useAuth();
+  const columns = useMemo(
+    () => (data == null ? void 0 : data.list_columns.map((col) => {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const {
+        component,
+        enableFilterModes,
+        enableAdvancedFilters,
+        filterComponent,
+        filterProps,
+        filterModeDescription,
+        filterMenu,
+        defaultOpr = ((_d = (_c = (_b = (_a = info == null ? void 0 : info.filters) == null ? void 0 : _a[col]) == null ? void 0 : _b.filters) == null ? void 0 : _c[0]) == null ? void 0 : _d.operator) || ""
+      } = getProps(header, specialKey.all, col);
+      const filterFn = fromFilterToFilterFn(col, defaultOpr);
+      const filters = ((_f = (_e = info == null ? void 0 : info.filters) == null ? void 0 : _e[col]) == null ? void 0 : _f.filters) || [];
+      const additionalProps = {};
+      if (component !== void 0) {
+        additionalProps.Header = (props) => parseFromValuesOrFunc(component, { api, auth, mrtProps: props });
+      }
+      return {
+        accessorKey: col,
+        accessorFn: (row) => getValue(row, col),
+        header: (_g = data == null ? void 0 : data.label_columns) == null ? void 0 : _g[col],
+        Filter: (props) => /* @__PURE__ */ jsx(
+          ColumnHeaderFilter,
+          {
+            enableFilterModes,
+            enableAdvancedFilters,
+            filterProps,
+            filterModeDescription,
+            filterMenu,
+            filters,
+            filterFn,
+            mrtProps: props,
+            children: filterComponent
+          }
+        ),
+        enableSorting: data == null ? void 0 : data.order_columns.includes(col),
+        filterFn: filters.length ? filterFn : void 0,
+        columnFilterModeOptions: filters.map((f) => fromFilterToFilterFn(col, f.operator)),
+        Cell: ({ cell, table, column, ...restCellProps }) => {
+          const globalFilter = table.getState().globalFilter;
+          const columnTextFilter = column.getFilterValue() || "";
+          const { component: component2, separator, truncate } = getProps(body, specialKey.all, col);
+          let highlight = [];
+          if (globalFilter) {
+            highlight.push(...globalFilter.split(textFilterSeparator).map((f) => f.trim()));
+          }
+          if (columnTextFilter && typeof columnTextFilter === "string") {
+            highlight.push(...columnTextFilter.split(textFilterSeparator).map((f) => f.trim()));
+          }
+          let value = cell.getValue();
+          if (typeof value === "number") {
+            value = value.toLocaleString();
+          } else if (value === null || value === void 0) {
+            value = "";
+          }
+          if (separator) {
+            value = value.split(separator);
+          }
+          let truncateObj = {};
+          if (truncate) {
+            if (Array.isArray(value)) {
+              truncateObj = value.map((v) => ({
+                original: v,
+                truncated: v.length > truncate ? `${v.slice(0, truncate)}...` : null
+              }));
+            } else {
+              truncateObj = {
+                original: value,
+                truncated: value.length > truncate ? `${value.slice(0, truncate)}...` : null
+              };
+            }
+          }
+          const functionProps = {
+            api,
+            auth,
+            data: cell.row.original,
+            highlight,
+            componentProps: { value },
+            mrtProps: { cell, table, column, ...restCellProps }
+          };
+          return /* @__PURE__ */ jsx(
+            FallbackWrapper,
+            {
+              fallback: /* @__PURE__ */ jsx(MultiLineHighlight, { highlight, truncate: truncateObj, children: value }),
+              functionProps,
+              children: component2
+            }
+          );
+        },
+        ...additionalProps,
+        ...getProps(columnProps, specialKey.all, col)
+      };
+    })) || [],
+    [
+      data == null ? void 0 : data.list_columns,
+      data == null ? void 0 : data.label_columns,
+      data == null ? void 0 : data.order_columns,
+      info,
+      columnProps,
+      specialKey.all,
+      api,
+      auth,
+      header,
+      body,
+      textFilterSeparator
+    ]
+  );
+  const [simpleCache, setSimpleCache] = useSetState({});
+  useEffect(() => {
+    if (columns.length) {
+      setSimpleCache({ [data.path]: columns });
+    }
+  }, [columns]);
+  return { columns: columns.length ? columns : (simpleCache == null ? void 0 : simpleCache[path]) || columns, manualFiltering: true };
+}
+export {
+  useColumns
+};

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

@@ -0,0 +1,73 @@
+import { jsx } from "react/jsx-runtime";
+import { convertId } from "../../../../Wrappers/ApiProvider/utils/convertId.mjs";
+import { HeaderBetweenInput } from "./ColumnHeaderFilter/HeaderInputs/HeaderBetweenInput.mjs";
+import { HeaderBooleanInput } from "./ColumnHeaderFilter/HeaderInputs/HeaderBooleanInput.mjs";
+import { HeaderDateInput } from "./ColumnHeaderFilter/HeaderInputs/HeaderDateInput.mjs";
+import { HeaderMultiSelectInput } from "./ColumnHeaderFilter/HeaderInputs/HeaderMultiSelectInput.mjs";
+import { HeaderSelectInput } from "./ColumnHeaderFilter/HeaderInputs/HeaderSelectInput.mjs";
+import { HeaderTagsInput } from "./ColumnHeaderFilter/HeaderInputs/HeaderTagsInput.mjs";
+import { HeaderTagsNumberInput } from "./ColumnHeaderFilter/HeaderInputs/HeaderTagsNumberInput.mjs";
+import { HeaderTextInput } from "./ColumnHeaderFilter/HeaderInputs/HeaderTextInput.mjs";
+const getBasicInput = (opr, schema) => {
+  if (!opr || !schema) {
+    return void 0;
+  }
+  switch (opr) {
+    case "tc":
+      return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderTextInput, { ...componentProps });
+    case "in":
+      switch (schema.type) {
+        case "Integer":
+          return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderTagsNumberInput, { ...componentProps });
+        case "Enum":
+          return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderTagsNumberInput, { data: schema.values, ...componentProps });
+      }
+      return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderTagsInput, { ...componentProps });
+    case "bw":
+      switch (schema.type) {
+        case "Date":
+        case "DateTime":
+          return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderDateInput, { type: "range", ...componentProps });
+        default:
+          return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderBetweenInput, { ...componentProps });
+      }
+    case "eq":
+    case "neq":
+      switch (schema.type) {
+        case "Boolean":
+          return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderBooleanInput, { ...componentProps });
+      }
+      break;
+    case "rel_o_m":
+    case "nrel_o_m":
+      return ({ componentProps }) => /* @__PURE__ */ jsx(
+        HeaderSelectInput,
+        {
+          data: schema.values.map((item) => ({ value: String(convertId(item.id)), label: item.value })),
+          ...componentProps
+        }
+      );
+    case "rel_m_m":
+    case "nrel_m_m":
+      return ({ componentProps }) => /* @__PURE__ */ jsx(
+        HeaderMultiSelectInput,
+        {
+          data: schema.values.map((item) => ({ value: String(convertId(item.id)), label: item.value })),
+          ...componentProps
+        }
+      );
+  }
+  switch (schema.type) {
+    case "Integer":
+      return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderNumberInput, { ...componentProps });
+    case "Enum":
+      return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderSelectInput, { data: schema.values, ...componentProps });
+    case "Date":
+    case "DateTime":
+      return ({ componentProps }) => /* @__PURE__ */ jsx(HeaderDateInput, { ...componentProps });
+  }
+  return void 0;
+};
+export {
+  getBasicInput
+};

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

@@ -0,0 +1,12 @@
+import { useApi } from "../../../hooks/api/useApi.mjs";
+function useData() {
+  const { data, loading } = useApi();
+  return {
+    data: (data == null ? void 0 : data.result) || [],
+    rowCount: (data == null ? void 0 : data.count) || 0,
+    state: { showLoadingOverlay: loading }
+  };
+}
+export {
+  useData
+};

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

@@ -0,0 +1,19 @@
+import { useApi } from "../../../hooks/api/useApi.mjs";
+function useEvent(onClickEntry) {
+  const { data } = useApi();
+  if (!onClickEntry) {
+    return null;
+  }
+  return {
+    mantineTableBodyRowProps: ({ row }) => ({
+      onClick: () => {
+        const id = data.ids[row.id];
+        onClickEntry(id, row.original);
+      },
+      style: { cursor: "pointer" }
+    })
+  };
+}
+export {
+  useEvent
+};

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

@@ -0,0 +1,18 @@
+import { useMemo } from "react";
+import { useApi } from "../../../hooks/api/useApi.mjs";
+import { fromFilterToFilterFn } from "../utils.mjs";
+function useFilters() {
+  const { info } = useApi();
+  return {
+    filterFns: useMemo(
+      () => Object.entries((info == null ? void 0 : info.filters) || {}).reduce((acc, [key, value]) => {
+        value.filters.forEach((filter) => acc[fromFilterToFilterFn(key, filter.operator)] = null);
+        return acc;
+      }, {}),
+      [info == null ? void 0 : info.filters]
+    )
+  };
+}
+export {
+  useFilters
+};

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

@@ -0,0 +1,30 @@
+import { DEBOUNCE_DELAY } from "fastapi-rtk/constants";
+import { useDebouncedValue, useDidUpdate } from "@mantine/hooks";
+import { useMemo, useState } from "react";
+import { useApi } from "../../../hooks/api/useApi.mjs";
+function useGlobalFilter() {
+  const { queryParams, setQueryParams } = useApi();
+  const existingGlobalFilter = useMemo(() => queryParams == null ? void 0 : queryParams.global_filter, [queryParams == null ? void 0 : queryParams.global_filter]);
+  const [globalFilter, setGlobalFilter] = useState(existingGlobalFilter || "");
+  const [debounced] = useDebouncedValue(globalFilter, DEBOUNCE_DELAY);
+  useDidUpdate(() => {
+    if (existingGlobalFilter && existingGlobalFilter !== debounced) {
+      setGlobalFilter(existingGlobalFilter);
+    }
+  }, [existingGlobalFilter]);
+  useDidUpdate(() => {
+    if (debounced) {
+      setQueryParams({ page: 0, global_filter: debounced });
+    } else {
+      (queryParams == null ? void 0 : queryParams.global_filter) && setQueryParams({ page: 0, global_filter: void 0 });
+    }
+  }, [debounced]);
+  return {
+    manualFiltering: true,
+    onGlobalFilterChange: setGlobalFilter,
+    state: { globalFilter }
+  };
+}
+export {
+  useGlobalFilter
+};

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

@@ -0,0 +1,44 @@
+import { DEFAULT_PAGE_SIZE, DEFAULT_PAGE, DEFAULT_PAGE_SIZE_OPTIONS } from "fastapi-rtk/constants";
+import { isTruthy } from "fastapi-rtk/utils";
+import { useMemo, useCallback } from "react";
+import { useApi } from "../../../hooks/api/useApi.mjs";
+function usePagination(hidePagination) {
+  const { data, queryParams, setQueryParams } = useApi();
+  const pagination = useMemo(
+    () => ({
+      pageIndex: (queryParams == null ? void 0 : queryParams.page) || DEFAULT_PAGE,
+      pageSize: (queryParams == null ? void 0 : queryParams.page_size) || DEFAULT_PAGE_SIZE
+    }),
+    [queryParams == null ? void 0 : queryParams.page, queryParams == null ? void 0 : queryParams.page_size]
+  );
+  const onPaginationChange = useCallback(
+    (func) => {
+      const newPagination = func(pagination);
+      if (!(data == null ? void 0 : data.count) && newPagination.pageIndex === 0) {
+        return;
+      }
+      setQueryParams({
+        page: newPagination.pageIndex,
+        page_size: newPagination.pageSize
+      });
+    },
+    [data == null ? void 0 : data.count, pagination, setQueryParams]
+  );
+  const rowsPerPageOptions = useMemo(
+    () => [
+      ...DEFAULT_PAGE_SIZE_OPTIONS,
+      ...isTruthy(queryParams == null ? void 0 : queryParams.page_size) && !DEFAULT_PAGE_SIZE_OPTIONS.includes(String(queryParams == null ? void 0 : queryParams.page_size)) ? [String(queryParams == null ? void 0 : queryParams.page_size)] : []
+    ],
+    [queryParams == null ? void 0 : queryParams.page_size]
+  );
+  return {
+    enablePagination: !hidePagination,
+    manualPagination: true,
+    state: { pagination },
+    onPaginationChange,
+    mantinePaginationProps: { rowsPerPageOptions }
+  };
+}
+export {
+  usePagination
+};

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

@@ -0,0 +1,43 @@
+import { useDidUpdate } from "@mantine/hooks";
+import { useMemo } from "react";
+import { useApi } from "../../../hooks/api/useApi.mjs";
+import { getProps, fromFilterFnToFilter } from "../utils.mjs";
+function useQueryParams(table, header) {
+  const { info, specialKey, setQueryParams } = useApi();
+  const filters = useMemo(() => {
+    const filters2 = [];
+    table.getState().columnFilters.forEach(({ id, value }) => {
+      var _a, _b, _c, _d, _e;
+      const { updateQueryParams = true, defaultOpr = ((_d = (_c = (_b = (_a = info == null ? void 0 : info.filters) == null ? void 0 : _a[id]) == null ? void 0 : _b.filters) == null ? void 0 : _c[0]) == null ? void 0 : _d.operator) || "" } = getProps(
+        header,
+        specialKey.all,
+        id
+      );
+      if (!updateQueryParams) {
+        return;
+      }
+      let opr = (_e = table.getState().columnFilterFns) == null ? void 0 : _e[id];
+      if (opr) {
+        opr = fromFilterFnToFilter(opr).operator;
+      } else {
+        opr = defaultOpr;
+      }
+      filters2.push({
+        id,
+        col: id,
+        opr,
+        value
+      });
+    });
+    return filters2;
+  }, [specialKey.all, table.getState().columnFilters]);
+  useDidUpdate(() => {
+    setQueryParams((prev) => ({
+      ...prev,
+      filters: [...(prev == null ? void 0 : prev.filters.filter((f) => !f.id)) ?? [], ...filters]
+    }));
+  }, [filters]);
+}
+export {
+  useQueryParams
+};

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

@@ -0,0 +1,33 @@
+import { useElementSize } from "@mantine/hooks";
+import { useMemo } from "react";
+function useSize(withBorder) {
+  const { ref: bottomToolbarRef, height: bottomToolbarHeight } = useElementSize();
+  const { ref: topToolbarRef, height: topToolbarHeight } = useElementSize();
+  const mantinePaperProps = useMemo(() => {
+    const props = { h: "100%", withBorder };
+    if (!withBorder) {
+      props.shadow = void 0;
+    }
+    return props;
+  }, [withBorder]);
+  const mantineTopToolbarProps = useMemo(() => ({ ref: topToolbarRef }), [topToolbarRef]);
+  const mantineBottomToolbarProps = useMemo(
+    () => ({ ref: bottomToolbarRef, pos: "sticky", bottom: 0 }),
+    [bottomToolbarRef]
+  );
+  const mantineTableContainerProps = useMemo(
+    () => ({
+      h: `calc(100% - ${topToolbarHeight + bottomToolbarHeight}px)`
+    }),
+    [topToolbarHeight, bottomToolbarHeight]
+  );
+  return {
+    mantinePaperProps,
+    mantineTopToolbarProps,
+    mantineBottomToolbarProps,
+    mantineTableContainerProps
+  };
+}
+export {
+  useSize
+};

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

@@ -0,0 +1,35 @@
+import { useMemo, useCallback } from "react";
+import { useApi } from "../../../hooks/api/useApi.mjs";
+function useSorting() {
+  const { queryParams, setQueryParams, data } = useApi();
+  const sorting = useMemo(
+    () => (queryParams == null ? void 0 : queryParams.order_column) ? [{ id: queryParams.order_column, desc: queryParams.order_direction === "desc" }] : [],
+    [queryParams == null ? void 0 : queryParams.order_column, queryParams == null ? void 0 : queryParams.order_direction]
+  );
+  const onSortingChange = useCallback(
+    (func) => {
+      const newSorting = func(sorting);
+      if (!newSorting.length) {
+        setQueryParams({
+          order_column: null,
+          order_direction: null
+        });
+        return;
+      }
+      const sortObj = newSorting[0];
+      setQueryParams({
+        order_column: data.order_columns.includes(sortObj.id) ? sortObj.id : `${sortObj.id}.id`,
+        order_direction: sortObj.desc ? "desc" : "asc"
+      });
+    },
+    [data == null ? void 0 : data.order_columns, setQueryParams, sorting]
+  );
+  return {
+    manualSorting: true,
+    state: { sorting },
+    onSortingChange
+  };
+}
+export {
+  useSorting
+};

package/dist/core/esm/Tables/NextGenDataGrid/hooks/useToolbar/basicToolbars.mjs

@@ -0,0 +1,22 @@
+import { jsx } from "react/jsx-runtime";
+import { MRT_ToggleFullScreenButton, MRT_ToggleDensePaddingButton, MRT_ShowHideColumnsButton, MRT_ToggleFiltersButton, MRT_ToggleGlobalFilterButton } 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 { Add } from "../../../../ActionIcons/Add/Add.mjs";
+import { Download } from "../../../../ActionIcons/Download/Download.mjs";
+import { Refresh } from "../../../../ActionIcons/Refresh/Refresh.mjs";
+import { Upload } from "../../../../ActionIcons/Upload/Upload.mjs";
+function getBasicToolbars(table, rules) {
+  return {
+    toggleGlobalFilter: /* @__PURE__ */ jsx(MRT_ToggleGlobalFilterButton, { table, disabled: false }, "basic-toggleGlobalFilter"),
+    filter: /* @__PURE__ */ jsx(MRT_ToggleFiltersButton, { table }, "basic-filter"),
+    refresh: /* @__PURE__ */ jsx(Refresh, { tooltipProps: { label: table.options.localization.refresh } }, "basic-refresh"),
+    add: (rules == null ? void 0 : rules.add) && /* @__PURE__ */ jsx(Add, { tooltipProps: { label: table.options.localization.add } }, "basic-add"),
+    download: (rules == null ? void 0 : rules.download) && /* @__PURE__ */ jsx(Download, { tooltipProps: { label: table.options.localization.download } }, "basic-download"),
+    upload: (rules == null ? void 0 : rules.upload) && /* @__PURE__ */ jsx(Upload, { tooltipProps: { label: table.options.localization.upload } }, "basic-upload"),
+    showHideColumns: /* @__PURE__ */ jsx(MRT_ShowHideColumnsButton, { table }, "basic-showHideColumns"),
+    toggleDensePadding: /* @__PURE__ */ jsx(MRT_ToggleDensePaddingButton, { table }, "basic-toggleDensePadding"),
+    toggleFullScreen: /* @__PURE__ */ jsx(MRT_ToggleFullScreenButton, { table }, "basic-toggleFullScreen")
+  };
+}
+export {
+  getBasicToolbars
+};

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

@@ -0,0 +1,101 @@
+import { jsx } from "react/jsx-runtime";
+import { SegmentedControl, Group, Box, Flex } from "@mantine/core";
+import { useMemo, useCallback } from "react";
+import { useApi } from "../../../../hooks/api/useApi.mjs";
+import { useAuth } from "../../../../hooks/auth/useAuth.mjs";
+import { FallbackWrapper } from "../../FallbackWrapper.mjs";
+import { getBasicToolbars } from "./basicToolbars.mjs";
+function renderCustomizedToolbars(customizer, basicToolbarsObj, functionProps, custom) {
+  Object.entries(customizer || {}).forEach(([key, value]) => {
+    if (key in basicToolbarsObj) {
+      basicToolbarsObj[key] = /* @__PURE__ */ jsx(FallbackWrapper, { fallback: basicToolbarsObj[key], functionProps, children: value }, `custom-${key}`);
+    }
+  });
+  let toolbars = Object.values(basicToolbarsObj);
+  Object.entries(custom || {}).forEach(([key, value]) => {
+    key = Number(key) - 1;
+    const Component = /* @__PURE__ */ jsx(FallbackWrapper, { functionProps, children: value }, `order-${key}`);
+    if (key > toolbars.length) {
+      toolbars.push(Component);
+    } else {
+      toolbars = [...toolbars.slice(0, key), Component, ...toolbars.slice(key)];
+    }
+  });
+  return /* @__PURE__ */ jsx(Flex, { gap: "0.125rem", align: "center", children: toolbars });
+}
+function useToolbar(toolbar = {}, quickFilters, hideToolbar) {
+  const { info, queryParams, setQueryParams } = useApi();
+  const api = useApi();
+  const auth = useAuth();
+  const { customizer, custom, leftToolbar } = toolbar;
+  const data = useMemo(() => {
+    if (!quickFilters) {
+      return [];
+    }
+    return [
+      { label: "All", value: "[]" },
+      ...quickFilters.map((filter) => ({ label: filter.name, value: JSON.stringify(filter.value) }))
+    ];
+  }, [quickFilters]);
+  const quickFilterUI = useMemo(() => {
+    if (!data.length) {
+      return null;
+    }
+    return /* @__PURE__ */ jsx(
+      SegmentedControl,
+      {
+        value: JSON.stringify((queryParams == null ? void 0 : queryParams.filters) || []),
+        onChange: (value) => setQueryParams({ filters: JSON.parse(value) }),
+        data
+      }
+    );
+  }, [queryParams == null ? void 0 : queryParams.filters, data, setQueryParams]);
+  const renderToolbarInternalActions = useCallback(
+    ({ table }) => {
+      const functionProps = {
+        api,
+        auth,
+        mrtProps: { table }
+      };
+      const rules = {
+        add: info == null ? void 0 : info.permissions.includes("can_post"),
+        download: info == null ? void 0 : info.permissions.includes("can_download"),
+        upload: info == null ? void 0 : info.permissions.includes("can_upload")
+      };
+      const basicToolbarsObj = getBasicToolbars(table, rules);
+      return renderCustomizedToolbars(customizer, basicToolbarsObj, functionProps, custom);
+    },
+    [api, auth, custom, customizer, info == null ? void 0 : info.permissions]
+  );
+  return {
+    renderToolbarInternalActions,
+    enableTopToolbar: !hideToolbar,
+    enableFilters: (customizer == null ? void 0 : customizer.filter) !== null,
+    ...useMemo(() => {
+      if (quickFilterUI && leftToolbar) {
+        throw new Error("quickFilters and toolbar.leftToolbar are mutually exclusive, please use only one of them");
+      }
+      const props = {};
+      if (quickFilterUI) {
+        props.renderTopToolbarCustomActions = () => /* @__PURE__ */ jsx(Group, { justify: "space-between", children: /* @__PURE__ */ jsx(Box, { children: quickFilterUI }) });
+        props.positionToolbarAlertBanner = "bottom";
+      }
+      if (leftToolbar) {
+        const { custom: custom2 } = leftToolbar;
+        props.renderTopToolbarCustomActions = ({ table }) => {
+          const functionProps = {
+            api,
+            auth,
+            mrtProps: { table }
+          };
+          return renderCustomizedToolbars(void 0, {}, functionProps, custom2);
+        };
+        props.positionToolbarAlertBanner = "bottom";
+      }
+      return props;
+    }, [api, auth, leftToolbar, quickFilterUI])
+  };
+}
+export {
+  useToolbar
+};