@pisell/materials 1.0.215 → 1.0.217

package/lib/components/table/hooks/useMergeColumnSetting.d.ts

@@ -0,0 +1,17 @@
+import { ModeType, StorageMode } from "../types";
+declare type Params = {
+    tableId: string;
+    defaultColumns: Record<string, any>[];
+    dispatch: (params: {
+        type: string;
+        payload: any;
+    }) => void;
+    storageMode: StorageMode;
+    currentViewMode: ModeType;
+};
+declare const useMergeColumnSetting: (params: Params) => {
+    columns: Record<string, any>[];
+    onChange: (newColumns: Record<string, any>[]) => void;
+    hideColumns: Record<string, any>[];
+};
+export default useMergeColumnSetting;

package/lib/components/table/hooks/useMergeColumnSetting.js

@@ -0,0 +1,58 @@
+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/table/hooks/useMergeColumnSetting.ts
+var useMergeColumnSetting_exports = {};
+__export(useMergeColumnSetting_exports, {
+  default: () => useMergeColumnSetting_default
+});
+module.exports = __toCommonJS(useMergeColumnSetting_exports);
+var import_react = require("react");
+var import_ahooks = require("ahooks");
+var import_utils = require("../Table/utils");
+var useMergeColumnSetting = (params) => {
+  const { tableId, defaultColumns, dispatch, storageMode, currentViewMode } = params;
+  const [columns, setColumns] = (0, import_react.useState)(defaultColumns);
+  const onChange = (0, import_ahooks.useMemoizedFn)((newColumns) => {
+    if (tableId && storageMode === "localStorage") {
+      (0, import_utils.setTableSettingToLocalStorage)({
+        tableId,
+        tableSettingObj: { column_setting: newColumns },
+        currentViewMode
+      });
+    }
+    dispatch({
+      type: "setDefaultColumns",
+      payload: newColumns
+    });
+  });
+  (0, import_react.useEffect)(() => {
+    setColumns(defaultColumns);
+  }, [defaultColumns]);
+  const hideColumns = (0, import_react.useMemo)(() => {
+    return columns.filter((item) => !(item == null ? void 0 : item.isShow));
+  }, [columns]);
+  return {
+    columns,
+    onChange,
+    hideColumns
+    // fixedColumns,
+    // sortColumns,
+  };
+};
+var useMergeColumnSetting_default = useMergeColumnSetting;

package/lib/components/table/hooks/useTableSetting.d.ts

@@ -0,0 +1,20 @@
+import { FilterType } from "../../filter/types";
+import { ColumnSettingType, DataSourceGroupType, GallerySettingType, GridViewType, ModeType, SortType } from "../types";
+declare type UseTableSettingProps = {
+    tableId?: string;
+    filter: FilterType;
+    columns: Record<string, any>[];
+    columnSetting?: ColumnSettingType;
+    dataSourceGroup?: DataSourceGroupType;
+    sort?: SortType;
+    view: GridViewType;
+    currentViewMode: ModeType;
+    gallery?: GallerySettingType;
+};
+declare const useTableSetting: (params: UseTableSettingProps) => {
+    setTableSetting: (values: Record<string, any>) => void;
+    tableSetting: {
+        [x: string]: any;
+    };
+};
+export default useTableSetting;

package/lib/components/table/hooks/useTableSetting.js

@@ -0,0 +1,205 @@
+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/table/hooks/useTableSetting.ts
+var useTableSetting_exports = {};
+__export(useTableSetting_exports, {
+  default: () => useTableSetting_default
+});
+module.exports = __toCommonJS(useTableSetting_exports);
+var import_react = require("react");
+var import_utils = require("../Table/utils");
+var useTableSetting = (params) => {
+  const {
+    tableId,
+    filter,
+    columnSetting,
+    dataSourceGroup,
+    sort,
+    view,
+    currentViewMode,
+    columns: propsColumns,
+    gallery
+  } = params;
+  const columnsMap = (0, import_react.useMemo)(() => {
+    return new Map(propsColumns.map((item) => [item.key, item]));
+  }, [propsColumns]);
+  const columns = (0, import_react.useMemo)(() => {
+    var _a;
+    if (currentViewMode === "grid") {
+      return propsColumns;
+    } else if (currentViewMode === "gallery") {
+      return (((_a = gallery == null ? void 0 : gallery.content) == null ? void 0 : _a.fields) || []).filter((item) => item.show).map((item) => columnsMap.get(item.columnKey)).filter(Boolean);
+    }
+    return propsColumns;
+  }, [propsColumns, currentViewMode, gallery, columnsMap]);
+  const { list, quickFilterMaxLength, sortButtonShow } = filter || {};
+  const defaultGalleryCoverSetting = (0, import_react.useMemo)(() => {
+    var _a, _b;
+    return {
+      coverObjectFit: (_a = gallery == null ? void 0 : gallery.cover) == null ? void 0 : _a.objectFit,
+      coverField: (_b = columns.find(
+        (column) => {
+          var _a2, _b2;
+          return column.key === ((_b2 = (_a2 = gallery == null ? void 0 : gallery.cover) == null ? void 0 : _a2.fields) == null ? void 0 : _b2[0]);
+        }
+      )) == null ? void 0 : _b.dataIndex,
+      compactMode: "default",
+      isShowLabel: true
+    };
+  }, [gallery, columns]);
+  const localStorageSettingKeyArr = (0, import_react.useMemo)(() => {
+    return (0, import_utils.getSettingKeyArrByMode)({
+      filter,
+      columnSetting,
+      dataSourceGroup,
+      sort,
+      mode: "localStorage",
+      currentViewMode
+    });
+  }, [tableId, filter, columnSetting, dataSourceGroup, sort, currentViewMode]);
+  const defaultKeyArr = (0, import_react.useMemo)(() => {
+    return (0, import_utils.getSettingKeyArrByMode)({
+      filter,
+      columnSetting,
+      dataSourceGroup,
+      sort,
+      mode: "",
+      currentViewMode
+    });
+  }, [
+    tableId,
+    filter,
+    columnSetting,
+    dataSourceGroup,
+    sort,
+    view,
+    currentViewMode
+  ]);
+  const tableLocalSetting = (0, import_react.useMemo)(() => {
+    const setting = {};
+    const allSetting = (0, import_utils.getTableSettingFromLocalStorage)(tableId);
+    const currentViewModeSetting = (0, import_utils.getTableSettingByCurrentViewMode)(
+      tableId,
+      currentViewMode
+    );
+    const mergedSetting = { ...allSetting, ...currentViewModeSetting };
+    localStorageSettingKeyArr.forEach((item) => {
+      var _a, _b, _c, _d;
+      if (item === "view_mode") {
+        setting[item] = view.multiple ? (mergedSetting == null ? void 0 : mergedSetting[item]) || view.defaultViewMode : view.defaultViewMode;
+      } else if (item === "filter_setting") {
+        setting[item] = (0, import_utils.mergeFilterSetting)({
+          list,
+          quickFilterMaxLength,
+          tableId,
+          sortButtonShow,
+          currentViewMode
+        });
+      } else if (item === "column_setting") {
+        setting[item] = (0, import_utils.mergeColumnSetting)({
+          columns,
+          tableId,
+          currentViewMode
+        });
+      } else if (item === "gallery_setting") {
+        setting[item] = {
+          ...mergedSetting == null ? void 0 : mergedSetting[item],
+          // 本地没有默认封面效果时取配置中的
+          coverObjectFit: ((_a = mergedSetting == null ? void 0 : mergedSetting[item]) == null ? void 0 : _a.coverObjectFit) || defaultGalleryCoverSetting.coverObjectFit,
+          coverField: ((_b = mergedSetting == null ? void 0 : mergedSetting[item]) == null ? void 0 : _b.coverField) || defaultGalleryCoverSetting.coverField,
+          compactMode: ((_c = mergedSetting == null ? void 0 : mergedSetting[item]) == null ? void 0 : _c.compactMode) || defaultGalleryCoverSetting.compactMode,
+          isShowLabel: ((_d = mergedSetting == null ? void 0 : mergedSetting[item]) == null ? void 0 : _d.isShowLabel) ?? defaultGalleryCoverSetting.isShowLabel
+        };
+      } else {
+        setting[item] = mergedSetting == null ? void 0 : mergedSetting[item];
+      }
+    });
+    return setting;
+  }, [
+    localStorageSettingKeyArr,
+    tableId,
+    view,
+    list,
+    quickFilterMaxLength,
+    tableId,
+    sortButtonShow,
+    columns,
+    currentViewMode,
+    gallery,
+    defaultGalleryCoverSetting
+  ]);
+  const defaultTableSetting = (0, import_react.useMemo)(() => {
+    const setting = {};
+    defaultKeyArr.forEach((item) => {
+      if (item === "column_setting") {
+        setting[item] = (0, import_utils.mergeColumnSetting)({
+          columns,
+          tableId,
+          currentViewMode
+        });
+      } else if (item === "filter_setting") {
+        setting[item] = (0, import_utils.mergeFilterSetting)({
+          list,
+          quickFilterMaxLength,
+          tableId: "",
+          sortButtonShow,
+          currentViewMode
+        });
+      } else if (item === "gallery_setting") {
+        setting[item] = {
+          // 取配置中的设置
+          coverObjectFit: defaultGalleryCoverSetting.coverObjectFit,
+          coverField: defaultGalleryCoverSetting.coverField,
+          compactMode: defaultGalleryCoverSetting.compactMode,
+          isShowLabel: defaultGalleryCoverSetting.isShowLabel
+        };
+      }
+    });
+    return setting;
+  }, [
+    defaultKeyArr,
+    columns,
+    defaultGalleryCoverSetting,
+    columns,
+    tableId,
+    currentViewMode,
+    list,
+    quickFilterMaxLength,
+    sortButtonShow
+  ]);
+  const setTableSetting = (values) => {
+    (0, import_utils.setFormValuesToLocalStorage)({
+      tableId,
+      allValues: values,
+      keys: localStorageSettingKeyArr,
+      currentViewMode
+    });
+  };
+  const tableSetting = (0, import_react.useMemo)(() => {
+    return {
+      ...tableLocalSetting,
+      ...defaultTableSetting
+    };
+  }, [tableLocalSetting, defaultTableSetting]);
+  return {
+    setTableSetting,
+    tableSetting
+  };
+};
+var useTableSetting_default = useTableSetting;

package/lib/components/table/hooks/useTransColumns.d.ts

@@ -0,0 +1,13 @@
+import { FormInstance } from "antd/es/form";
+declare type UseTransColumnsProps = {
+    columns: Record<string, any>[];
+    form: FormInstance;
+    localPagination: boolean;
+    handleSave?: (row: Record<string, any>) => void;
+    handleResize?: (index: number) => (e: any, p2: any) => void;
+    dragSort: boolean;
+};
+declare const useTransColumns: (params: UseTransColumnsProps) => {
+    columns: any[];
+};
+export default useTransColumns;

package/lib/components/table/hooks/useTransColumns.js

@@ -0,0 +1,195 @@
+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/table/hooks/useTransColumns.tsx
+var useTransColumns_exports = {};
+__export(useTransColumns_exports, {
+  default: () => useTransColumns_default
+});
+module.exports = __toCommonJS(useTransColumns_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var import_utils = require("@pisell/utils");
+var import_numberFilter = __toESM(require("../TableFilter/numberFilter"));
+var import_stringFilter = __toESM(require("../TableFilter/stringFilter"));
+var import_selectFilter = __toESM(require("../TableFilter/selectFilter"));
+var import_SortIcon = __toESM(require("../TableFilter/SortIcon"));
+var import_utils2 = require("../Table/fields/utils");
+var import_locales = require("../../../locales");
+var genOnCell = (position) => (_) => {
+  let styleObj = {};
+  let notGroupStyle = {};
+  if (position === "start") {
+    styleObj = {
+      borderLeft: "1px solid #EAECF0",
+      borderRadius: "8px 0px 0px 0px",
+      padding: "12px"
+    };
+    notGroupStyle = {
+      borderLeft: "1px solid #EAECF0"
+    };
+  } else if (position === "end") {
+    styleObj = {
+      borderRight: "1px solid #EAECF0",
+      borderRadius: "0px 8px 0px 0px"
+    };
+    notGroupStyle = {
+      borderRight: "1px solid #EAECF0"
+    };
+  }
+  return {
+    style: _.__is_group ? {
+      borderTop: "1px solid var(--Gray-200, #EAECF0)",
+      ...styleObj
+    } : {
+      ...notGroupStyle
+    }
+  };
+};
+var useTransColumns = (params) => {
+  var _a;
+  const { columns, form, handleSave, handleResize, dragSort } = params;
+  const group = import_antd.Form.useWatch("group_by", { form, preserve: true });
+  const groupField = (_a = group == null ? void 0 : group[0]) == null ? void 0 : _a.field;
+  const groupFieldRender = (0, import_react.useCallback)(
+    (text, record) => {
+      if (!groupField)
+        return void 0;
+      const { children } = record;
+      const fieldCol = columns.find(
+        (item) => `${item.dataIndex}` === groupField
+      );
+      const { render, dataIndex } = fieldCol || {};
+      let dom = /* @__PURE__ */ import_react.default.createElement("div", null, (0, import_utils2.getValueByKeys)(children == null ? void 0 : children[0], dataIndex || groupField.split(",")));
+      if (render) {
+        dom = render(
+          (0, import_utils2.getValueByKeys)(children == null ? void 0 : children[0], dataIndex),
+          record.children[0]
+        );
+      }
+      return /* @__PURE__ */ import_react.default.createElement(
+        "div",
+        {
+          style: {
+            display: "flex",
+            justifyContent: "space-between",
+            alignItems: "start"
+          }
+        },
+        /* @__PURE__ */ import_react.default.createElement("span", null, dom),
+        /* @__PURE__ */ import_react.default.createElement("span", null, children.length, " ", (0, import_locales.getText)("table-column-group-records"))
+      );
+    },
+    [groupField, columns]
+  );
+  const _columns = (0, import_react.useMemo)(() => {
+    let newColumns = columns.filter(
+      (item) => !((0, import_utils.isBoolean)(item.isShow) && !item.isShow)
+    );
+    if (dragSort && !groupField) {
+      newColumns.unshift({
+        key: "__sort",
+        width: 60,
+        align: "center"
+      });
+    }
+    return newColumns.map((col, index) => {
+      var _a2;
+      let position = "";
+      if (index === 0) {
+        position = "start";
+      } else if (index === newColumns.length - 1) {
+        position = "end";
+      }
+      let groupObj = {};
+      if (position === "start" && groupField) {
+        groupObj = {
+          fixed: "left",
+          width: 350,
+          render: (text, record) => {
+            var _a3;
+            if (record.__is_group && groupFieldRender) {
+              return groupFieldRender(text, record);
+            }
+            return ((_a3 = col == null ? void 0 : col.render) == null ? void 0 : _a3.call(col, text, record)) || text;
+          }
+        };
+      }
+      const item = {
+        editable: col.editable || true,
+        dataIndex: col.dataIndex,
+        title: col.title,
+        field_type: col.field_type,
+        lock: col.lock,
+        width: col.width || 250,
+        action: col.action || "",
+        render: col.render,
+        contentClassName: col.contentClassName || ""
+      };
+      let filterObj = {};
+      if (col.defaultFilters) {
+        if (col.field_type === "number") {
+          filterObj = (0, import_numberFilter.default)({ dataIndex: col.dataIndex });
+        }
+        if (col.field_type === "text") {
+          filterObj = (0, import_stringFilter.default)({ dataIndex: col.dataIndex });
+        }
+      }
+      if (((_a2 = col.filters) == null ? void 0 : _a2.length) > 0) {
+        filterObj = {
+          ...(0, import_selectFilter.default)({
+            dataIndex: col.dataIndex,
+            filters: col.filters
+          }),
+          filters: col.filters
+        };
+      }
+      return {
+        ...col,
+        ...filterObj,
+        ...groupObj,
+        sortIcon: (props) => /* @__PURE__ */ import_react.default.createElement(import_SortIcon.default, { ...props }),
+        onCell: (record) => ({
+          record,
+          ...item,
+          ...genOnCell(position)(record),
+          handleSave
+        }),
+        onHeaderCell: (record) => ({
+          record,
+          ...item,
+          onResize: handleResize == null ? void 0 : handleResize(index)
+        })
+      };
+    });
+  }, [columns, groupFieldRender, dragSort, groupField]);
+  return {
+    columns: _columns
+  };
+};
+var useTransColumns_default = useTransColumns;

package/lib/components/table/hooks/useTransDataSource.d.ts

@@ -0,0 +1,11 @@
+import { FormInstance } from "antd/es/form";
+import { FilterType } from "../../filter/types";
+declare type UseTransDataSourceParams = {
+    form: FormInstance;
+    localPagination: boolean;
+    dataSource: Record<string, any>[];
+    rowKey: string | ((params: any) => string);
+    filter: FilterType;
+};
+declare const useTransDataSource: (params: UseTransDataSourceParams) => Record<string, any>[];
+export default useTransDataSource;

package/lib/components/table/hooks/useTransDataSource.js

@@ -0,0 +1,89 @@
+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/table/hooks/useTransDataSource.ts
+var useTransDataSource_exports = {};
+__export(useTransDataSource_exports, {
+  default: () => useTransDataSource_default
+});
+module.exports = __toCommonJS(useTransDataSource_exports);
+var import_react = require("react");
+var import_utils = require("@pisell/utils");
+var import_antd = require("antd");
+var import_utils2 = require("../Table/utils");
+var defaultObj = {};
+var useTransDataSource = (params) => {
+  const {
+    form,
+    localPagination,
+    dataSource: pDataSource,
+    rowKey,
+    filter
+  } = params;
+  const sort = import_antd.Form.useWatch("order_by", { form, preserve: true });
+  const group = import_antd.Form.useWatch("group_by", { form, preserve: true });
+  const filters = import_antd.Form.useWatch("filters", { form, preserve: true }) || defaultObj;
+  const sortObj = (0, import_react.useMemo)(() => {
+    if (!sort) {
+      return void 0;
+    }
+    const [key, value, type] = sort.split(":");
+    return {
+      sortKey: key,
+      sortValue: value,
+      sortType: type
+    };
+  }, [sort]);
+  const groupDetail = (0, import_react.useMemo)(() => {
+    if ((0, import_utils.isArr)(group) && group.length) {
+      return group;
+    }
+    return void 0;
+  }, [group]);
+  const filterLocalArr = (0, import_react.useMemo)(() => {
+    if (!(filter == null ? void 0 : filter.show) || !(filter == null ? void 0 : filter.list)) {
+      return [];
+    }
+    return filter == null ? void 0 : filter.list.filter((item) => item.localFilter);
+  }, [filter]);
+  const dataSource = (0, import_react.useMemo)(() => {
+    if (!localPagination) {
+      return pDataSource;
+    }
+    let newDataSource = pDataSource;
+    if (filterLocalArr.length) {
+      newDataSource = (0, import_utils2.filterDataSource)(newDataSource, filters, filterLocalArr);
+    }
+    if (sortObj) {
+      newDataSource = (0, import_utils2.sortDataSource)(newDataSource, sortObj);
+    }
+    if (groupDetail) {
+      newDataSource = (0, import_utils2.groupDataSource)(newDataSource, groupDetail, rowKey);
+    }
+    return newDataSource;
+  }, [
+    pDataSource,
+    localPagination,
+    sortObj,
+    groupDetail,
+    filterLocalArr,
+    filters
+  ]);
+  return dataSource;
+};
+var useTransDataSource_default = useTransDataSource;

package/lib/components/table/hooks/useTransDataSourceGroupSetting.d.ts

@@ -0,0 +1,7 @@
+import { DataSourceGroupType } from "../types";
+declare type UseTransDataSourceGroupSettingParams = {
+    dataSourceGroup?: DataSourceGroupType;
+    originColumnsMap: Map<string, any>;
+};
+declare const useTransDataSourceGroupSetting: (params: UseTransDataSourceGroupSettingParams) => DataSourceGroupType | undefined;
+export default useTransDataSourceGroupSetting;

package/lib/components/table/hooks/useTransDataSourceGroupSetting.js

@@ -0,0 +1,50 @@
+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/table/hooks/useTransDataSourceGroupSetting.ts
+var useTransDataSourceGroupSetting_exports = {};
+__export(useTransDataSourceGroupSetting_exports, {
+  default: () => useTransDataSourceGroupSetting_default
+});
+module.exports = __toCommonJS(useTransDataSourceGroupSetting_exports);
+var import_react = require("react");
+var useTransDataSourceGroupSetting = (params) => {
+  const { dataSourceGroup, originColumnsMap } = params;
+  return (0, import_react.useMemo)(() => {
+    if (dataSourceGroup && dataSourceGroup.show && dataSourceGroup.list) {
+      return {
+        ...dataSourceGroup,
+        list: dataSourceGroup.list.map((item) => {
+          let { name, label, columnKey, isCustom } = item;
+          if (!isCustom && columnKey && originColumnsMap.has(columnKey)) {
+            const column = originColumnsMap.get(columnKey);
+            name = column.dataIndex || name;
+            label = column.title || label;
+          }
+          return {
+            ...item,
+            name,
+            label
+          };
+        })
+      };
+    }
+    return dataSourceGroup;
+  }, [dataSourceGroup, originColumnsMap]);
+};
+var useTransDataSourceGroupSetting_default = useTransDataSourceGroupSetting;

package/lib/components/table/hooks/useTransFilterSetting.d.ts

@@ -0,0 +1,7 @@
+import { FilterType } from "../../filter/types";
+declare type UseTransFilterSettingParams = {
+    filter: FilterType;
+    originColumnsMap: Map<string, any>;
+};
+declare const useTransFilterSetting: (params: UseTransFilterSettingParams) => FilterType;
+export default useTransFilterSetting;