@pisell/materials 3.0.62 → 6.0.2

package/lib/components/dataSourceComponents/dataSourceTable/hooks/useDataSourceKey.js

@@ -0,0 +1,50 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/dataSourceTable/hooks/useDataSourceKey.ts
+var useDataSourceKey_exports = {};
+__export(useDataSourceKey_exports, {
+  default: () => useDataSourceKey_default
+});
+module.exports = __toCommonJS(useDataSourceKey_exports);
+var import_react = require("react");
+var import_utils = require("@pisell/utils");
+var import_useDataSource = __toESM(require("../../hooks/useDataSource"));
+var useDataSourceKey = () => {
+  const { dataSource } = (0, import_useDataSource.default)();
+  const dataSourceKey = (0, import_react.useMemo)(() => {
+    return (0, import_utils.isString)(dataSource) ? dataSource : (dataSource == null ? void 0 : dataSource.key) || (dataSource == null ? void 0 : dataSource.tableName);
+  }, [dataSource]);
+  const dataSourceKeyRef = (0, import_react.useRef)(dataSourceKey);
+  dataSourceKeyRef.current = dataSourceKey;
+  return {
+    dataSourceKey,
+    dataSourceKeyRef
+  };
+};
+var useDataSourceKey_default = useDataSourceKey;

package/lib/components/dataSourceComponents/dataSourceTable/hooks/useDesignMode.d.ts

@@ -0,0 +1,2 @@
+declare const useDesignMode: (props: any, { registerValueVariable, openDrawer, closeDrawer, data }: any) => void;
+export default useDesignMode;

package/lib/components/dataSourceComponents/dataSourceTable/hooks/useDesignMode.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/dataSourceTable/hooks/useDesignMode.ts
+var useDesignMode_exports = {};
+__export(useDesignMode_exports, {
+  default: () => useDesignMode_default
+});
+module.exports = __toCommonJS(useDesignMode_exports);
+var import_react = require("react");
+var useDesignMode = (props, { registerValueVariable, openDrawer, closeDrawer, data }) => {
+  const {
+    __designMode,
+    componentId,
+    operation
+  } = props;
+  const { items } = operation || {};
+  const prevItemsRef = (0, import_react.useRef)([]);
+  (0, import_react.useEffect)(() => {
+    var _a;
+    if (__designMode === "design" && (items == null ? void 0 : items.length) && ((_a = prevItemsRef.current) == null ? void 0 : _a.length)) {
+      const changedItem = items.find((item) => {
+        const prevItem = prevItemsRef.current.find((prev) => prev.key === item.key);
+        if (!prevItem)
+          return false;
+        if (item.actionType !== prevItem.actionType) {
+          return true;
+        }
+        return false;
+      });
+      if (changedItem) {
+        if (["view", "edit", "custom"].includes(changedItem.actionType)) {
+          registerValueVariable == null ? void 0 : registerValueVariable(componentId, {
+            currentRecord: (data == null ? void 0 : data[0]) || null
+          });
+          openDrawer(changedItem);
+        } else {
+          closeDrawer();
+        }
+      }
+    }
+    prevItemsRef.current = items;
+  }, [items, __designMode]);
+};
+var useDesignMode_default = useDesignMode;

package/lib/components/dataSourceComponents/dataSourceTable/hooks/useDrawerState.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="react" />
+import { Drawer } from 'antd';
+import { OperationItem } from '../type';
+declare const useDrawerState: (operationContent?: {
+    [key: string]: import("react").ReactNode;
+} | undefined) => {
+    drawerVisible: boolean;
+    setDrawerVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    openDrawer: (item: OperationItem) => void;
+    closeDrawer: () => void;
+    drawerContent: import("react").ReactNode;
+    Container: typeof Drawer | {
+        (props: import("../../../pisellModal").PisellModalProps): import("react").JSX.Element;
+        confirm: (props: import("../../../pisellModal/components/functions").PisellModalFuncProps) => {
+            destroy: () => void;
+            update: (configUpdate: import("antd").ModalFuncProps | ((prevConfig: import("antd").ModalFuncProps) => import("antd").ModalFuncProps)) => void;
+        };
+        info: (props: import("../../../pisellModal/components/functions").PisellModalFuncProps) => {
+            destroy: () => void;
+            update: (configUpdate: import("antd").ModalFuncProps | ((prevConfig: import("antd").ModalFuncProps) => import("antd").ModalFuncProps)) => void;
+        };
+        error: (props: import("../../../pisellModal/components/functions").PisellModalFuncProps) => {
+            destroy: () => void;
+            update: (configUpdate: import("antd").ModalFuncProps | ((prevConfig: import("antd").ModalFuncProps) => import("antd").ModalFuncProps)) => void;
+        };
+        warn: (props: import("../../../pisellModal/components/functions").PisellModalFuncProps) => any;
+        warning: (props: import("../../../pisellModal/components/functions").PisellModalFuncProps) => {
+            destroy: () => void;
+            update: (configUpdate: import("antd").ModalFuncProps | ((prevConfig: import("antd").ModalFuncProps) => import("antd").ModalFuncProps)) => void;
+        };
+        success: (props: import("../../../pisellModal/components/functions").PisellModalFuncProps) => {
+            destroy: () => void;
+            update: (configUpdate: import("antd").ModalFuncProps | ((prevConfig: import("antd").ModalFuncProps) => import("antd").ModalFuncProps)) => void;
+        };
+        Information: (props: import("../../../pisellModal/components/Information").InformationProps) => import("react").JSX.Element;
+    };
+    containerProps: {};
+};
+export default useDrawerState;

package/lib/components/dataSourceComponents/dataSourceTable/hooks/useDrawerState.js

@@ -0,0 +1,107 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/dataSourceTable/hooks/useDrawerState.ts
+var useDrawerState_exports = {};
+__export(useDrawerState_exports, {
+  default: () => useDrawerState_default
+});
+module.exports = __toCommonJS(useDrawerState_exports);
+var import_antd = require("antd");
+var import_react = require("react");
+var import_pisellModal = __toESM(require("../../../pisellModal"));
+var sizeMap = {
+  small: 400,
+  middle: 600,
+  large: 800
+};
+var useDrawerState = (operationContent) => {
+  const [drawerVisible, setDrawerVisible] = (0, import_react.useState)(false);
+  const [item, setItem] = (0, import_react.useState)(null);
+  const timerRef = (0, import_react.useRef)();
+  (0, import_react.useEffect)(() => {
+    return () => {
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+      }
+    };
+  }, []);
+  const openDrawer = (item2) => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+    }
+    setDrawerVisible(true);
+    setItem(item2);
+  };
+  const closeDrawer = () => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+    }
+    setDrawerVisible(false);
+    timerRef.current = setTimeout(() => {
+      setItem(null);
+      timerRef.current = void 0;
+    }, 300);
+  };
+  const drawerContent = (0, import_react.useMemo)(() => {
+    if ((item == null ? void 0 : item.key) && operationContent) {
+      return operationContent[item.key];
+    }
+    return null;
+  }, [item, operationContent]);
+  const containerProps = (0, import_react.useMemo)(() => {
+    if (!item) {
+      return {};
+    }
+    const otherProps = {};
+    if ((item == null ? void 0 : item.openMode) === "modal") {
+      otherProps.footer = null;
+    }
+    return {
+      width: sizeMap[item == null ? void 0 : item.openContentSize],
+      title: item == null ? void 0 : item.openTitle,
+      ...otherProps
+    };
+  }, [item]);
+  const Container = (0, import_react.useMemo)(() => {
+    if ((item == null ? void 0 : item.openMode) === "drawer") {
+      return import_antd.Drawer;
+    }
+    return import_pisellModal.default;
+  }, [item == null ? void 0 : item.openMode]);
+  return {
+    drawerVisible,
+    setDrawerVisible,
+    openDrawer,
+    closeDrawer,
+    drawerContent,
+    Container,
+    containerProps
+  };
+};
+var useDrawerState_default = useDrawerState;

package/lib/components/dataSourceComponents/dataSourceTable/hooks/useFormat.d.ts

@@ -0,0 +1,44 @@
+import { Field } from '../../provider/dataSource/DataSourceContext';
+export declare type ListResult = {
+    data: any[];
+    count: number;
+    page: number;
+    pageSize: number;
+};
+export declare type UseFormatParams = {
+    dataSourceKey: string;
+    fields: Field[];
+};
+export declare type FormatListResultParams = {
+    list: any[];
+    count: number;
+    page: number;
+    size: number;
+} | {
+    data: any[];
+    meta: {
+        count: number;
+        page: number;
+        pageSize: number;
+    };
+};
+export declare type FilterValue = {
+    [key: string]: any;
+};
+export declare type FilterOperator = '$includes' | '$dateAfter' | '$dateBefore' | '$eq' | '$in' | '$isTruly' | '$and';
+export declare type SimpleFilterValue = {
+    [key in Exclude<FilterOperator, '$and'>]?: any;
+};
+export declare type AndFilterValue = {
+    $and: FilterCondition[];
+};
+export declare type FilterConditionValue = SimpleFilterValue | AndFilterValue;
+export declare type FilterCondition = {
+    [key: string]: FilterConditionValue;
+} | AndFilterValue;
+declare const useFormat: ({ dataSourceKey, fields }: UseFormatParams) => {
+    formatListResult: (res: FormatListResultParams) => ListResult;
+    formatListParams: (params: any) => any;
+    formatCreateUpdateParams: (params: any) => any;
+};
+export default useFormat;

package/lib/components/dataSourceComponents/dataSourceTable/hooks/useFormat.js

@@ -0,0 +1,173 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/dataSourceTable/hooks/useFormat.ts
+var useFormat_exports = {};
+__export(useFormat_exports, {
+  default: () => useFormat_default
+});
+module.exports = __toCommonJS(useFormat_exports);
+var import_ahooks = require("ahooks");
+var import_utils = require("../../fields/utils");
+var import_utils2 = require("@pisell/utils");
+var import_dayjs = __toESM(require("dayjs"));
+var formatFilter = (filterValue, fields) => {
+  const conditions = [];
+  if (!filterValue || !(fields == null ? void 0 : fields.length)) {
+    return JSON.stringify({});
+  }
+  if (filterValue._keywords) {
+    const keywordFields = fields.filter((item) => ["string", "number", "text"].includes(item.type)).map((item) => ({
+      [item.name]: {
+        $includes: filterValue._keywords
+      }
+    }));
+    if (keywordFields.length > 0) {
+      conditions.push({
+        $or: keywordFields
+      });
+    }
+  }
+  const fieldsMap = fields.reduce((acc, field) => {
+    if (field.name) {
+      acc[field.name] = field;
+    }
+    return acc;
+  }, {});
+  const normalConditions = [];
+  Object.entries(filterValue).forEach(([key, value]) => {
+    var _a;
+    if (key === "_keywords" || value === void 0 || value === null || value === "" || (0, import_utils2.isArr)(value) && value.length === 0) {
+      return;
+    }
+    const field = fieldsMap[key];
+    if (!((_a = field == null ? void 0 : field.uiSchema) == null ? void 0 : _a["x-component"])) {
+      return;
+    }
+    const filterFunc = import_utils.formFieldFilterFuncMap[field.uiSchema["x-component"]];
+    if (!filterFunc) {
+      return;
+    }
+    const condition = filterFunc(value, field);
+    if (condition) {
+      normalConditions.push({ [key]: condition });
+    }
+  });
+  if (normalConditions.length > 0) {
+    conditions.push({ $and: normalConditions });
+  }
+  const filterCondition = conditions.length ? { $and: conditions } : {};
+  return JSON.stringify(filterCondition);
+};
+var formatSort = (sortValue) => {
+  if (!sortValue)
+    return void 0;
+  const [field, order] = sortValue.split(":");
+  const prefix = order === "desc" ? "-" : "";
+  return [`${prefix}${field}`];
+};
+var formatCreateUpdateParamsUtils = (params, fields) => {
+  if (!params || !(fields == null ? void 0 : fields.length)) {
+    return params;
+  }
+  const formattedParams = { ...params };
+  fields.forEach((field) => {
+    var _a, _b, _c, _d;
+    const fieldName = field.name;
+    const value = params[fieldName];
+    if (((_a = field.uiSchema) == null ? void 0 : _a["x-component"]) === "TimePicker" && value) {
+      if (import_dayjs.default.isDayjs(value)) {
+        formattedParams[fieldName] = value.format("HH:mm:ss");
+      } else if ((0, import_utils2.isString)(value)) {
+        const timeArr = value.split(":");
+        const hours = ((_b = timeArr[0]) == null ? void 0 : _b.padStart(2, "0")) || "00";
+        const minutes = ((_c = timeArr[1]) == null ? void 0 : _c.padStart(2, "0")) || "00";
+        const seconds = ((_d = timeArr[2]) == null ? void 0 : _d.padStart(2, "0")) || "00";
+        formattedParams[fieldName] = `${hours}:${minutes}:${seconds}`;
+      }
+    }
+  });
+  return formattedParams;
+};
+var customApiFormatFilter = (filter) => {
+  return {
+    ...filter
+  };
+};
+var useFormat = ({ dataSourceKey, fields }) => {
+  const formatListResult = (0, import_ahooks.useMemoizedFn)(
+    (res) => {
+      if (dataSourceKey === "pisell2-api" && "list" in res) {
+        return {
+          data: res.list,
+          count: res.count,
+          page: res.page,
+          pageSize: res.size
+        };
+      }
+      if ("meta" in res) {
+        return {
+          data: res.data,
+          count: res.meta.count,
+          page: res.meta.page,
+          pageSize: res.meta.pageSize
+        };
+      }
+      return res;
+    }
+  );
+  const formatListParams = (0, import_ahooks.useMemoizedFn)((params) => {
+    if (!dataSourceKey) {
+      return {
+        ...params,
+        filter: formatFilter(params.filter, fields),
+        sort: formatSort(params.sort)
+      };
+    }
+    if (dataSourceKey === "pisell2-api") {
+      return {
+        page: (params == null ? void 0 : params.page) || 1,
+        size: (params == null ? void 0 : params.pageSize) || 10,
+        ...customApiFormatFilter(params.filter || {})
+      };
+    }
+    return params;
+  });
+  const formatCreateUpdateParams = (0, import_ahooks.useMemoizedFn)((params) => {
+    if (!dataSourceKey) {
+      return formatCreateUpdateParamsUtils(params, fields);
+    }
+    return params;
+  });
+  return {
+    formatListResult,
+    formatListParams,
+    formatCreateUpdateParams
+  };
+};
+var useFormat_default = useFormat;

package/lib/components/dataSourceComponents/dataSourceTable/hooks/usePagination.d.ts

@@ -0,0 +1,16 @@
+declare type UsePaginationProps = {
+    data: {
+        count: number;
+        page: number;
+        pageSize: number;
+        [key: string]: any;
+    };
+};
+declare const usePagination: ({ data }: UsePaginationProps) => {
+    total: number;
+    current: number;
+    pageSize: number;
+    size: string;
+    showSizeChanger: boolean;
+};
+export default usePagination;

package/lib/components/dataSourceComponents/dataSourceTable/hooks/usePagination.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/dataSourceTable/hooks/usePagination.ts
+var usePagination_exports = {};
+__export(usePagination_exports, {
+  default: () => usePagination_default
+});
+module.exports = __toCommonJS(usePagination_exports);
+var import_react = require("react");
+var usePagination = ({ data }) => {
+  return (0, import_react.useMemo)(() => {
+    return {
+      total: data == null ? void 0 : data.count,
+      current: data == null ? void 0 : data.page,
+      pageSize: data == null ? void 0 : data.pageSize,
+      size: "large",
+      showSizeChanger: (data == null ? void 0 : data.count) > 50
+    };
+  }, [data]);
+};
+var usePagination_default = usePagination;

package/lib/components/dataSourceComponents/dataSourceTable/hooks/useTableProps.d.ts

@@ -0,0 +1,78 @@
+import React from 'react';
+import { DataSourceTableProps } from '../type';
+import { OperationItem } from '../type';
+interface UseTablePropsProps {
+    data: any;
+    originProps: DataSourceTableProps;
+    openDrawer: (type: OperationItem) => void;
+    closeDrawer: () => void;
+    refreshData: () => void;
+    handleFilterChange: (changedFields: any, allFields: any) => void;
+    tableRef: any;
+}
+/**
+ * 处理table的props
+ * 转换title
+ * @param props
+ * @returns
+ */
+declare const useTableProps: (props: UseTablePropsProps) => {
+    title: number | boolean | Iterable<React.ReactNode> | React.JSX.Element | (() => React.ReactNode) | null | undefined;
+    pagination: {
+        total: number;
+        current: number;
+        pageSize: number;
+        size: string;
+        showSizeChanger: boolean;
+    };
+    columns: import("./useColumns").Column[];
+    subTitle: number | boolean | Iterable<React.ReactNode> | React.JSX.Element | (() => React.ReactNode) | null | undefined;
+    buttons: any[] | null;
+    filter: React.JSX.Element | null;
+    onRow: (record: any) => any;
+    titleButtons?: {
+        show: boolean;
+        maxCount: number;
+        items: OperationItem[];
+    } | undefined;
+    operation?: {
+        show: boolean;
+        title: string;
+        width: number;
+        align: "center" | "left" | "right";
+        fixed: false | "left" | "right";
+        type: "button" | "link";
+        items: OperationItem[];
+    } | undefined;
+    operationContent?: {
+        [key: string]: React.ReactNode;
+    } | undefined;
+    dataSource: import("../../provider/dataSource/DataSourceContext").DataSourceType;
+    search?: {
+        show: boolean;
+        placeholder: string;
+    } | undefined;
+    __designMode: string;
+    componentId: string;
+    clickToDetail?: {
+        show: boolean;
+        useCustomAction: boolean;
+        actionType: string;
+        openMode: "modal" | "drawer";
+        openContentSize: "small" | "large" | "middle";
+        openTitle: string;
+        key: string;
+    } | undefined;
+    filterBy?: Record<string, any> | undefined;
+    sortBy: string;
+    tabs?: {
+        show: boolean;
+        type: string;
+        items: {
+            name: string;
+            filterBy: Record<string, any>;
+            sortBy: string;
+        }[];
+    } | undefined;
+};
+export default useTableProps;