@pisell/materials 1.0.215 → 1.0.217

package/lib/components/table/Table/utils.js

@@ -29,10 +29,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/components/table/Table/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
-  calcFilterSort: () => calcFilterSort
+  calcFilterSort: () => calcFilterSort,
+  filterDataSource: () => filterDataSource,
+  getCurrentViewModeFromLocalStorage: () => getCurrentViewModeFromLocalStorage,
+  getIdByRowKey: () => getIdByRowKey,
+  getSettingKeyArrByMode: () => getSettingKeyArrByMode,
+  getTableSettingByCurrentViewMode: () => getTableSettingByCurrentViewMode,
+  getTableSettingFromLocalStorage: () => getTableSettingFromLocalStorage,
+  groupDataSource: () => groupDataSource,
+  mergeColumnSetting: () => mergeColumnSetting,
+  mergeFilterSetting: () => mergeFilterSetting,
+  omit: () => omit,
+  setFormValuesToLocalStorage: () => setFormValuesToLocalStorage,
+  setTableSettingToLocalStorage: () => setTableSettingToLocalStorage,
+  sortDataSource: () => sortDataSource
 });
 module.exports = __toCommonJS(utils_exports);
 var import_dayjs = __toESM(require("dayjs"));
+var import_utils = require("@pisell/utils");
+var import_fields = require("./fields");
+var import_utils2 = require("./fields/utils");
+var tableKeyPrefix = "table-setting";
 var transColumnsMap = (columns) => {
   return columns.reduce((p, c) => {
     return {
@@ -102,7 +119,322 @@ var calcFilterSort = ({ dataSource, filter, sort, columns }) => {
   }
   return newDataSource;
 };
+var getColumnsFromLocalStorage = (tableId, currentViewMode) => {
+  if (!tableId)
+    return {};
+  const { column_setting } = getTableSettingByCurrentViewMode(tableId, currentViewMode) || {};
+  const col = column_setting;
+  if (col) {
+    const colKeyMap = col.reduce(
+      (p, c) => {
+        p[c.key] = c;
+        return p;
+      },
+      {}
+    );
+    return colKeyMap;
+  }
+  return {};
+};
+var mergeColumnSetting = ({
+  columns,
+  tableId,
+  currentViewMode
+}) => {
+  if (!tableId)
+    return columns;
+  const colKeyMap = getColumnsFromLocalStorage(tableId, currentViewMode);
+  const newColumns = columns.map((item, index) => {
+    const col = colKeyMap[item.key];
+    let sortIndex = index;
+    if ((0, import_utils.isBoolean)(item.fixed) && item.fixed || item.fixed === "left") {
+      sortIndex = -99;
+    } else if (item.fixed === "right") {
+      sortIndex = 9999;
+    }
+    if (col) {
+      sortIndex = [true, false, "left", "right"].includes(item.fixed) ? sortIndex : col.sortIndex;
+      return {
+        ...item,
+        width: col.width ?? item.width,
+        isShow: col.isShow ?? true,
+        sortIndex
+      };
+    }
+    return { ...item, isShow: true, sortIndex };
+  });
+  newColumns.sort((a, b) => a.sortIndex - b.sortIndex);
+  return newColumns;
+};
+var sortDataSource = (dataSource, sortObj) => {
+  const { sortKey, sortValue, sortType } = sortObj;
+  const newDataSource = [...dataSource];
+  const sorter2 = (sortKey2, sortType2) => {
+    return (a, b) => {
+      const aValue = (0, import_utils2.getValueByKeys)(a, sortKey2.split(","));
+      const bValue = (0, import_utils2.getValueByKeys)(b, sortKey2.split(","));
+      if (sortType2 === "string") {
+        if (sortValue === "asc") {
+          return aValue == null ? void 0 : aValue.localeCompare(bValue);
+        }
+        return bValue == null ? void 0 : bValue.localeCompare(aValue);
+      }
+      if (sortType2 === "date") {
+        if (sortValue === "asc") {
+          return new Date(bValue).getTime() - new Date(aValue).getTime();
+        }
+        return new Date(aValue).getTime() - new Date(bValue).getTime();
+      }
+      if (sortType2 === "number") {
+        if (sortValue === "asc") {
+          return (Number(aValue) || 0) - (Number(bValue) || 0);
+        }
+        return (Number(bValue) || 0) - (Number(aValue) || 0);
+      }
+    };
+  };
+  newDataSource.sort(sorter2(sortKey, sortType));
+  return newDataSource;
+};
+var getIdByRowKey = (item, rowKey) => {
+  if ((0, import_utils.isString)(rowKey)) {
+    return item[rowKey];
+  } else if ((0, import_utils.isFunction)(rowKey)) {
+    return item[rowKey(item)];
+  }
+  return item[rowKey || "id"];
+};
+var groupDataSource = (dataSource, group, rowKey) => {
+  const groupField = group[0].field;
+  if (!groupField) {
+    return dataSource;
+  }
+  const dataIndex = groupField.split(",");
+  let newDataSource = [...dataSource];
+  newDataSource = Object.values(
+    newDataSource.reduce((pre, cur, index) => {
+      const groupValue = (0, import_utils2.getValueByKeys)(cur, dataIndex);
+      if (!pre[groupValue]) {
+        pre[groupValue] = {
+          __table_group_field: groupField,
+          __is_group: true,
+          children: [cur]
+        };
+      } else {
+        pre[groupValue].children.push(cur);
+      }
+      pre[groupValue].__rowKey = `group-${pre[groupValue].children.map((item) => getIdByRowKey(item, rowKey)).join("-")}`;
+      pre[groupValue].id = pre[groupValue].__rowKey;
+      return { ...pre };
+    }, {})
+  );
+  return newDataSource;
+};
+var setTableSettingToLocalStorage = ({
+  tableId,
+  tableSettingObj,
+  currentViewMode
+}) => {
+  if (!tableId)
+    return;
+  const originData = localStorage.getItem(getTableKey(tableId));
+  let newData = {};
+  if (originData && (0, import_utils.isJson)(originData)) {
+    const data = JSON.parse(originData) || {};
+    newData = {
+      ...data
+    };
+  }
+  const { view_mode, ...itemSetting } = tableSettingObj;
+  newData = {
+    ...newData,
+    view_mode: view_mode || newData.view_mode,
+    [currentViewMode]: {
+      ...newData[currentViewMode] || {},
+      ...itemSetting
+    }
+  };
+  localStorage.setItem(getTableKey(tableId), JSON.stringify(newData));
+};
+var getTableSettingFromLocalStorage = (tableId) => {
+  if (!tableId)
+    return {};
+  const originData = localStorage.getItem(getTableKey(tableId));
+  if (originData && (0, import_utils.isJson)(originData)) {
+    return JSON.parse(originData);
+  }
+  return {};
+};
+var getCurrentViewModeFromLocalStorage = (tableId) => {
+  const allSetting = getTableSettingFromLocalStorage(tableId);
+  return allSetting["view_mode"];
+};
+var getTableSettingByCurrentViewMode = (tableId, currentViewMode) => {
+  const allSetting = getTableSettingFromLocalStorage(tableId);
+  return allSetting[currentViewMode];
+};
+var setFormValuesToLocalStorage = ({
+  tableId,
+  allValues,
+  keys,
+  currentViewMode
+}) => {
+  if (!tableId)
+    return;
+  let obj = {};
+  keys == null ? void 0 : keys.forEach((key) => {
+    obj[key] = allValues == null ? void 0 : allValues[key];
+  });
+  setTableSettingToLocalStorage({
+    tableId,
+    tableSettingObj: obj,
+    currentViewMode
+  });
+};
+var getTableKey = (tableId) => `${tableKeyPrefix}-${tableId}`;
+var mergeFilterSetting = ({
+  list,
+  quickFilterMaxLength,
+  tableId,
+  sortButtonShow,
+  currentViewMode
+}) => {
+  var _a, _b;
+  if (!sortButtonShow) {
+    return {
+      quickFilter: [],
+      otherFilter: [],
+      notSortFilter: list
+    };
+  }
+  const { filter_setting } = getTableSettingByCurrentViewMode(tableId, currentViewMode) || {};
+  const { quickFilter, otherFilter } = filter_setting || {};
+  const notSortList = [];
+  const sortList = [];
+  list.forEach((item) => {
+    if (item.sort) {
+      sortList.push(item);
+    } else {
+      notSortList.push(item);
+    }
+  });
+  if (!tableId || !quickFilter || !otherFilter) {
+    return {
+      quickFilter: ((_a = sortList == null ? void 0 : sortList.slice) == null ? void 0 : _a.call(sortList, 0, quickFilterMaxLength)) || [],
+      otherFilter: ((_b = sortList == null ? void 0 : sortList.slice) == null ? void 0 : _b.call(sortList, quickFilterMaxLength)) || [],
+      notSortFilter: notSortList
+    };
+  }
+  const quickFilterMap = new Map(
+    quickFilter.map((item, index) => [item.key, { ...item, sortIndex: index }])
+  );
+  const otherFilterMap = new Map(
+    otherFilter.map((item, index) => [item.key, { ...item, sortIndex: index }])
+  );
+  let newQuickFilter = Array.from({ length: 200 });
+  let newOtherFilter = Array.from({ length: 200 });
+  let notSortFilter = [];
+  list.forEach((item) => {
+    if (!item.sort) {
+      notSortFilter.push(item);
+    } else if (quickFilterMap.has(item.key)) {
+      if ((0, import_utils.isNumber)(quickFilterMap.get(item.key).sortIndex)) {
+        newQuickFilter[quickFilterMap.get(item.key).sortIndex] = item;
+      } else {
+        newQuickFilter.push(item);
+      }
+    } else if (otherFilterMap.has(item.key)) {
+      if ((0, import_utils.isNumber)(otherFilterMap.get(item.key).sortIndex)) {
+        newOtherFilter[otherFilterMap.get(item.key).sortIndex] = item;
+      } else {
+        newOtherFilter.push(item);
+      }
+    } else {
+      newOtherFilter.push(item);
+    }
+  });
+  return {
+    quickFilter: newQuickFilter.filter(Boolean),
+    otherFilter: newOtherFilter.filter(Boolean),
+    notSortFilter
+  };
+};
+var filterDataSource = (dataSource, filters, filterLocalArr) => {
+  const fnArr = filterLocalArr.map((filterItem) => {
+    if (!filters[filterItem.name]) {
+      return null;
+    }
+    const { filterFn } = import_fields.fieldMaps[filterItem.type];
+    if (!(0, import_utils.isFunction)(filterFn)) {
+      return null;
+    }
+    return (item) => {
+      try {
+        return filterFn({
+          value: filters[filterItem.name],
+          item,
+          key: filterItem.name
+        });
+      } catch (error) {
+        return false;
+      }
+    };
+  }).filter(Boolean);
+  return dataSource.filter((item) => {
+    return !fnArr.some((fn) => {
+      return !(fn == null ? void 0 : fn(item));
+    });
+  });
+};
+var getSettingKeyArrByMode = ({
+  filter,
+  columnSetting,
+  dataSourceGroup,
+  sort,
+  mode,
+  currentViewMode
+}) => {
+  const keyArr = [];
+  if ((filter == null ? void 0 : filter.show) && (filter == null ? void 0 : filter.storageMode) == mode) {
+    keyArr.push("filter_setting");
+  }
+  if (((columnSetting == null ? void 0 : columnSetting.storageMode) || "") == mode && currentViewMode === "gallery") {
+    keyArr.push("gallery_setting", "column_setting");
+  }
+  if (((columnSetting == null ? void 0 : columnSetting.storageMode) || "") == mode && currentViewMode === "grid") {
+    keyArr.push("column_setting");
+  }
+  if ((dataSourceGroup == null ? void 0 : dataSourceGroup.show) && ((dataSourceGroup == null ? void 0 : dataSourceGroup.storageMode) || "") == mode) {
+    keyArr.push("group_by");
+  }
+  if ((sort == null ? void 0 : sort.show) && sort.storageMode == mode) {
+    keyArr.push("order_by");
+  }
+  keyArr.push("view_mode");
+  return keyArr;
+};
+var omit = (obj, keys) => {
+  const shallowCopy = Object.assign({}, obj);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    delete shallowCopy[key];
+  }
+  return shallowCopy;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  calcFilterSort
+  calcFilterSort,
+  filterDataSource,
+  getCurrentViewModeFromLocalStorage,
+  getIdByRowKey,
+  getSettingKeyArrByMode,
+  getTableSettingByCurrentViewMode,
+  getTableSettingFromLocalStorage,
+  groupDataSource,
+  mergeColumnSetting,
+  mergeFilterSetting,
+  omit,
+  setFormValuesToLocalStorage,
+  setTableSettingToLocalStorage,
+  sortDataSource
 });

package/lib/components/table/TableFilter/SortIcon.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="react" />
+import React from "react";
 interface SortIconProps {
     sortOrder: null | "ascend" | "descend";
 }
-declare const SortIcon: (props: SortIconProps) => JSX.Element;
+declare const SortIcon: (props: SortIconProps) => React.JSX.Element;
 export default SortIcon;

package/lib/components/table/TableFilter/numberFilter.js

@@ -36,6 +36,7 @@ var import_react = __toESM(require("react"));
 var import_antd = require("antd");
 var import_FilterFunnel01 = __toESM(require("@pisell/icon/es/FilterFunnel01"));
 var import_FilterFunnel01Fill = __toESM(require("@pisell/icon/es/FilterFunnel01Fill"));
+var import_locales = require("../../../locales");
 var import_index = require("./index.less");
 var getColumnNumberProps = ({
   dataIndex
@@ -65,7 +66,7 @@ var getColumnNumberProps = ({
             };
             setSelectedKeys([newVal]);
           },
-          placeholder: "Min",
+          placeholder: (0, import_locales.getText)("table-filter-min"),
           onPressEnter: () => confirm(),
           style: { width: 105 }
         }
@@ -73,7 +74,7 @@ var getColumnNumberProps = ({
         import_antd.InputNumber,
         {
           value: (_b = selectedKeys == null ? void 0 : selectedKeys[0]) == null ? void 0 : _b.max,
-          placeholder: "Max",
+          placeholder: (0, import_locales.getText)("table-filter-max"),
           onChange: (value) => {
             const newVal = {
               ...(selectedKeys == null ? void 0 : selectedKeys[0]) || {},
@@ -100,9 +101,9 @@ var getColumnNumberProps = ({
             },
             block: true
           },
-          "Clear"
+          (0, import_locales.getText)("table-filter-clear")
         ),
-        /* @__PURE__ */ import_react.default.createElement(import_antd.Button, { type: "primary", onClick: () => confirm(), block: true }, "Filter")
+        /* @__PURE__ */ import_react.default.createElement(import_antd.Button, { type: "primary", onClick: () => confirm(), block: true }, (0, import_locales.getText)("table-filter-filter"))
       )
     );
   },

package/lib/components/table/TableFilter/selectFilter.js

@@ -36,6 +36,7 @@ var import_react = __toESM(require("react"));
 var import_antd = require("antd");
 var import_FilterFunnel01Fill = __toESM(require("@pisell/icon/es/FilterFunnel01Fill"));
 var import_FilterFunnel01 = __toESM(require("@pisell/icon/es/FilterFunnel01"));
+var import_locales = require("../../../locales");
 var import_index = require("./index.less");
 var FilterDropdown = (props) => {
   const { setSelectedKeys, selectedKeys, confirm, clearFilters, filters } = props;
@@ -99,7 +100,7 @@ var FilterDropdown = (props) => {
           block: true,
           style: { flex: 1 }
         },
-        "Clear"
+        (0, import_locales.getText)("table-filter-clear")
       ),
       /* @__PURE__ */ import_react.default.createElement(
         import_antd.Button,
@@ -109,7 +110,7 @@ var FilterDropdown = (props) => {
           block: true,
           style: { flex: 1 }
         },
-        "Filter"
+        (0, import_locales.getText)("table-filter-filter")
       )
     )
   );

package/lib/components/table/TableFilter/stringFilter.js

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(stringFilter_exports);
 var import_react = __toESM(require("react"));
 var import_antd = require("antd");
 var import_SearchLg = __toESM(require("@pisell/icon/es/SearchLg"));
+var import_locales = require("../../../locales");
 var import_index = require("./index.less");
 var getColumnStringProps = ({
   dataIndex
@@ -55,7 +56,7 @@ var getColumnStringProps = ({
       import_antd.Input,
       {
         prefix: /* @__PURE__ */ import_react.default.createElement(import_SearchLg.default, null),
-        placeholder: "Search",
+        placeholder: (0, import_locales.getText)("table-filter-search"),
         value: selectedKeys[0],
         onChange: (e) => setSelectedKeys(e.target.value ? [e.target.value] : []),
         onPressEnter: () => confirm(),
@@ -78,7 +79,7 @@ var getColumnStringProps = ({
           block: true,
           style: { flex: 1 }
         },
-        "Clear"
+        (0, import_locales.getText)("table-filter-clear")
       ),
       /* @__PURE__ */ import_react.default.createElement(
         import_antd.Button,
@@ -88,7 +89,7 @@ var getColumnStringProps = ({
           block: true,
           style: { flex: 1 }
         },
-        "Filter"
+        (0, import_locales.getText)("table-filter-filter")
       )
     )
   ),

package/lib/components/table/View/index.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { GridViewProps } from "../types";
+declare const View: (props: GridViewProps & {
+    setTableSetting: (values: Record<string, any>) => void;
+}) => React.JSX.Element;
+export default View;

package/lib/components/table/View/index.js

@@ -0,0 +1,75 @@
+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/View/index.tsx
+var View_exports = {};
+__export(View_exports, {
+  default: () => View_default
+});
+module.exports = __toCommonJS(View_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var import_Table = __toESM(require("../Table"));
+var import_Gallery = __toESM(require("../Gallery"));
+var View = (props) => {
+  const {
+    dataSource,
+    columns,
+    dispatch,
+    style,
+    filter,
+    sort,
+    buttons,
+    actionButtons,
+    title,
+    summary,
+    onValuesChange,
+    columnSetting,
+    dataSourceGroup,
+    view,
+    gallery,
+    setTableSetting,
+    ...other
+  } = props;
+  const form = import_antd.Form.useFormInstance();
+  const viewMode = import_antd.Form.useWatch("view_mode", {
+    form,
+    preserve: true
+  });
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, viewMode === "grid" && /* @__PURE__ */ import_react.default.createElement(import_Table.default, { tableProps: other, filter, setTableSetting }), viewMode === "gallery" && /* @__PURE__ */ import_react.default.createElement(
+    import_Gallery.default,
+    {
+      loading: other == null ? void 0 : other.loading,
+      gallery,
+      pagination: other.pagination,
+      filter,
+      rowKey: other.rowKey
+    }
+  ));
+};
+var View_default = View;

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

@@ -0,0 +1,21 @@
+declare type useGenScrollParams = {
+    wrapHeight: number;
+    scroll?: {
+        x: number;
+        y: number;
+        scrollToFirstRowOnChange?: boolean;
+        autoCalc?: boolean;
+    };
+    columns: any[];
+};
+declare const useGenScroll: (params: useGenScrollParams) => {
+    x: number;
+    y: number;
+    scrollToFirstRowOnChange?: boolean | undefined;
+    autoCalc?: boolean | undefined;
+} | {
+    x: any;
+    y: number;
+    scrollToFirstRowOnChange: boolean | undefined;
+} | undefined;
+export default useGenScroll;

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

@@ -0,0 +1,42 @@
+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/useGenScroll.ts
+var useGenScroll_exports = {};
+__export(useGenScroll_exports, {
+  default: () => useGenScroll_default
+});
+module.exports = __toCommonJS(useGenScroll_exports);
+var import_react = require("react");
+var useGenScroll = (params) => {
+  const { wrapHeight, scroll: propsScroll, columns } = params;
+  const scroll = (0, import_react.useMemo)(() => {
+    if (propsScroll == null ? void 0 : propsScroll.autoCalc) {
+      return {
+        x: (propsScroll == null ? void 0 : propsScroll.x) || columns.reduce((p, c) => {
+          return p + (c.width || 250);
+        }, 0),
+        y: (propsScroll == null ? void 0 : propsScroll.y) || Math.max(wrapHeight - 48 - 50 - 24, 100),
+        scrollToFirstRowOnChange: propsScroll == null ? void 0 : propsScroll.scrollToFirstRowOnChange
+      };
+    }
+    return propsScroll;
+  }, [propsScroll, wrapHeight, columns]);
+  return scroll;
+};
+var useGenScroll_default = useGenScroll;

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

@@ -0,0 +1,16 @@
+import React from "react";
+import { FormInstance } from "antd/es/form";
+declare type UseGenTableComponentsParams = {
+    form: FormInstance;
+};
+declare const useGenTableComponents: (params: UseGenTableComponentsParams) => {
+    header: {
+        row: React.FC<any>;
+        cell: React.FC<import("../Table/tableConfig/header").CustomHeaderCellProps>;
+    };
+    body: {
+        row: React.FC<import("../Table/tableConfig/body").RowProps>;
+        cell: React.FC<import("../Table/tableConfig/body").EditableCellProps>;
+    };
+};
+export default useGenTableComponents;

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

@@ -0,0 +1,59 @@
+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/useGenTableComponents.ts
+var useGenTableComponents_exports = {};
+__export(useGenTableComponents_exports, {
+  default: () => useGenTableComponents_default
+});
+module.exports = __toCommonJS(useGenTableComponents_exports);
+var import_react = require("react");
+var import_antd = require("antd");
+var import_utils = require("@pisell/utils");
+var import_header = __toESM(require("../Table/tableConfig/header"));
+var import_body = __toESM(require("../Table/tableConfig/body"));
+var useGenTableComponents = (params) => {
+  const { form } = params;
+  const group = import_antd.Form.useWatch("group_by", { form, preserve: true });
+  const isGroup = (0, import_react.useMemo)(() => {
+    return (0, import_utils.isArr)(group) && group.length > 0;
+  }, [group]);
+  return (0, import_react.useMemo)(() => {
+    return {
+      header: {
+        row: import_header.default.Row,
+        cell: import_header.default.Cell
+      },
+      body: {
+        row: import_body.default.Row,
+        cell: import_body.default.Coll
+      }
+    };
+  }, [isGroup]);
+};
+var useGenTableComponents_default = useGenTableComponents;