@pisell/materials 3.0.62 → 6.0.1

package/lib/components/dataSourceComponents/dataSourceTable/BaseTable.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { DataSourceTableProps } from './type';
+declare const BaseTable: (props: DataSourceTableProps) => React.JSX.Element;
+export default BaseTable;

package/lib/components/dataSourceComponents/dataSourceTable/BaseTable.js

@@ -0,0 +1,137 @@
+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/BaseTable.tsx
+var BaseTable_exports = {};
+__export(BaseTable_exports, {
+  default: () => BaseTable_default
+});
+module.exports = __toCommonJS(BaseTable_exports);
+var import_react = __toESM(require("react"));
+var import_ahooks = require("ahooks");
+var import_table = __toESM(require("../../table"));
+var import_useVariables = __toESM(require("../hooks/useVariables"));
+var import_ActionsProvider = __toESM(require("../provider/actions/ActionsProvider"));
+var import_useDrawerState = __toESM(require("./hooks/useDrawerState"));
+var import_useDesignMode = __toESM(require("./hooks/useDesignMode"));
+var import_useComponentId = __toESM(require("../hooks/useComponentId"));
+var import_useTableQuery = __toESM(require("./hooks/useTableQuery"));
+var import_useDataSource = __toESM(require("../hooks/useDataSource"));
+var import_TableSettingProvider = __toESM(require("./provider/tableSetting/TableSettingProvider"));
+var import_useDataSourceKey = __toESM(require("./hooks/useDataSourceKey"));
+var import_useTableProps = __toESM(require("./hooks/useTableProps"));
+var BaseTable = (props) => {
+  const {
+    columns: propsColumns,
+    dataSource,
+    operationContent,
+    ...others
+  } = props;
+  const tableRef = (0, import_react.useRef)(null);
+  const componentId = (0, import_useComponentId.default)(props);
+  const { registerValueVariable } = (0, import_useVariables.default)();
+  const { list } = (0, import_useDataSource.default)();
+  const { data } = list;
+  const { dataSourceKey, dataSourceKeyRef } = (0, import_useDataSourceKey.default)();
+  const {
+    drawerVisible,
+    setDrawerVisible,
+    openDrawer,
+    closeDrawer,
+    containerProps,
+    Container,
+    drawerContent
+  } = (0, import_useDrawerState.default)(operationContent);
+  const { queryPageConfig, handleValuesChange, refreshData, handleFilterChange } = (0, import_useTableQuery.default)(props);
+  (0, import_useDesignMode.default)(props, {
+    registerValueVariable,
+    openDrawer,
+    closeDrawer,
+    data: data == null ? void 0 : data.data
+  });
+  (0, import_ahooks.useUpdateEffect)(() => {
+    refreshData();
+  }, [dataSourceKey]);
+  (0, import_react.useEffect)(() => {
+    if (dataSourceKeyRef.current) {
+      list == null ? void 0 : list.run(queryPageConfig);
+    } else {
+      list == null ? void 0 : list.mutate([]);
+    }
+  }, [queryPageConfig]);
+  (0, import_react.useEffect)(() => {
+    registerValueVariable == null ? void 0 : registerValueVariable(componentId, {
+      currentDataSource: dataSource
+    });
+  }, [dataSource]);
+  const handleCloseDrawer = () => {
+    closeDrawer();
+    registerValueVariable == null ? void 0 : registerValueVariable(componentId, {
+      currentRecord: null
+    });
+  };
+  const transformProps = (0, import_useTableProps.default)({
+    data,
+    originProps: props,
+    openDrawer,
+    closeDrawer,
+    refreshData,
+    handleFilterChange,
+    tableRef
+  });
+  return /* @__PURE__ */ import_react.default.createElement(import_TableSettingProvider.default, null, /* @__PURE__ */ import_react.default.createElement(
+    import_table.default,
+    {
+      ref: tableRef,
+      ...others,
+      ...transformProps,
+      dataSource: (data == null ? void 0 : data.data) || [],
+      loading: list == null ? void 0 : list.loading,
+      onValuesChange: handleValuesChange
+    }
+  ), /* @__PURE__ */ import_react.default.createElement(
+    import_ActionsProvider.default,
+    {
+      visible: drawerVisible,
+      setVisible: setDrawerVisible,
+      refreshTableData: refreshData
+    },
+    /* @__PURE__ */ import_react.default.createElement(
+      Container,
+      {
+        ...containerProps,
+        open: drawerVisible,
+        onClose: handleCloseDrawer,
+        onCancel: handleCloseDrawer,
+        destroyOnClose: true
+      },
+      drawerContent
+    )
+  ));
+};
+var BaseTable_default = BaseTable;

package/lib/components/dataSourceComponents/dataSourceTable/filter/index.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import './index.less';
+interface BaseFilterItem {
+    name?: string;
+    value: string;
+    label?: string;
+    type?: string;
+    isHidden: boolean;
+    isCustom?: boolean;
+}
+interface FilterProps {
+    componentId: string;
+    filterBy: Record<string, any>;
+    quickFilterMaxLength?: number;
+    sortButtonShow?: boolean;
+    mode?: 'simple' | 'complex';
+    items: BaseFilterItem[];
+    handleValuesChange: (changedFields: any, allFields: any) => void;
+    show: boolean;
+    search: {
+        show: boolean;
+        placeholder: string;
+        key: string;
+    };
+}
+declare const Filter: (props: FilterProps) => React.JSX.Element;
+export default Filter;

package/lib/components/dataSourceComponents/dataSourceTable/filter/index.js

@@ -0,0 +1,182 @@
+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/filter/index.tsx
+var filter_exports = {};
+__export(filter_exports, {
+  default: () => filter_default
+});
+module.exports = __toCommonJS(filter_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var import_ahooks = require("ahooks");
+var import_icons = require("@ant-design/icons");
+var import_Input = __toESM(require("../../fields/Input"));
+var import_useDataSource = __toESM(require("../../hooks/useDataSource"));
+var import_FilterButton = __toESM(require("../../../filter/components/FilterButton"));
+var import_utils = require("./utils");
+var import_index = require("./index.less");
+var defaultArr = [];
+var Filter = (props) => {
+  const {
+    componentId,
+    items = defaultArr,
+    mode = "simple",
+    quickFilterMaxLength = 3,
+    sortButtonShow = false,
+    handleValuesChange,
+    search,
+    filterBy,
+    show
+  } = props;
+  const [form] = import_antd.Form.useForm();
+  const { dataSource } = (0, import_useDataSource.default)();
+  const [list, setList] = (0, import_react.useState)(() => {
+    const storedOrder = (0, import_utils.getStoredFilterOrder)(componentId);
+    return storedOrder || {
+      quickFilter: [],
+      otherFilter: []
+    };
+  });
+  const filterList = (0, import_react.useMemo)(() => {
+    return items.filter((item) => !(item == null ? void 0 : item.isHidden));
+  }, [items]);
+  const filterDom = (0, import_react.useMemo)(() => {
+    if (!show) {
+      return null;
+    }
+    return (0, import_utils.genFilterItems)(list.quickFilter, dataSource);
+  }, [list.quickFilter, show]);
+  (0, import_react.useEffect)(() => {
+    const storedOrder = (0, import_utils.getStoredFilterOrder)(componentId);
+    if (!storedOrder) {
+      const newList = {
+        quickFilter: filterList.slice(0, quickFilterMaxLength),
+        otherFilter: filterList.slice(quickFilterMaxLength)
+      };
+      setList(newList);
+      (0, import_utils.saveFilterOrder)(componentId, newList);
+      return;
+    }
+    const orderedItems = {
+      quickFilter: [],
+      otherFilter: []
+    };
+    const itemMap = new Map(filterList.map((item) => [item.name, item]));
+    storedOrder.quickFilter.forEach((stored) => {
+      const item = itemMap.get(stored.name);
+      if (item) {
+        orderedItems.quickFilter.push(item);
+        itemMap.delete(stored.name);
+      }
+    });
+    storedOrder.otherFilter.forEach((stored) => {
+      const item = itemMap.get(stored.name);
+      if (item) {
+        orderedItems.otherFilter.push(item);
+        itemMap.delete(stored.name);
+      }
+    });
+    const remainingItems = Array.from(itemMap.values());
+    remainingItems.forEach((item) => {
+      if (orderedItems.quickFilter.length < quickFilterMaxLength) {
+        orderedItems.quickFilter.push(item);
+      } else {
+        orderedItems.otherFilter.push(item);
+      }
+    });
+    if (quickFilterMaxLength && orderedItems.quickFilter.length > quickFilterMaxLength) {
+      const overflow = orderedItems.quickFilter.splice(quickFilterMaxLength);
+      orderedItems.otherFilter.unshift(...overflow);
+    }
+    setList(orderedItems);
+    (0, import_utils.saveFilterOrder)(componentId, orderedItems);
+  }, [filterList, quickFilterMaxLength, componentId]);
+  const onChange = (newVal) => {
+    setList(newVal);
+    (0, import_utils.saveFilterOrder)(componentId, newVal);
+  };
+  const renderItem = (0, import_ahooks.useMemoizedFn)((item, otherProps) => {
+    const getField = (0, import_utils.genGetField)(dataSource);
+    const field = getField(item.name);
+    const cptDom = (0, import_utils.field2Cpt)(field, item, {
+      labelCol: { span: 24 },
+      style: (style) => {
+        return {
+          ...style || {},
+          width: "100%"
+        };
+      },
+      ...otherProps
+    });
+    return cptDom;
+  });
+  const onValuesChange = (0, import_ahooks.useDebounceFn)(
+    (changedFields, allFields) => {
+      handleValuesChange(changedFields, allFields);
+    },
+    { wait: 300 }
+  ).run;
+  const searchDom = (0, import_react.useMemo)(() => {
+    return (search == null ? void 0 : search.show) ? /* @__PURE__ */ import_react.default.createElement(
+      import_Input.default,
+      {
+        name: search.key || "_keywords",
+        placeholder: search.placeholder,
+        renderMode: "edit",
+        prefix: /* @__PURE__ */ import_react.default.createElement(import_icons.SearchOutlined, null),
+        style: { width: 200, margin: 0 },
+        allowClear: true
+      }
+    ) : null;
+  }, [search]);
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_antd.Form,
+    {
+      labelCol: { span: 0 },
+      form,
+      size: "large",
+      layout: "inline",
+      className: "filter-form-wrapper",
+      onValuesChange
+    },
+    searchDom,
+    filterDom,
+    show && /* @__PURE__ */ import_react.default.createElement(
+      import_FilterButton.default,
+      {
+        value: list,
+        quickFilterMaxLength,
+        formFiltersPrefix: "",
+        onChange,
+        renderItem
+      }
+    )
+  );
+};
+var filter_default = Filter;

package/lib/components/dataSourceComponents/dataSourceTable/filter/index.less

@@ -0,0 +1,4 @@
+.filter-form-wrapper {
+  display: flex;
+  gap: 8px;
+}

package/lib/components/dataSourceComponents/dataSourceTable/filter/utils.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { FilterItemProps } from '../../../filter/types';
+import { DataSourceType, Field } from '../../provider/dataSource/DataSourceContext';
+export declare const genGetField: (dataSource?: DataSourceType) => (key: string) => Field;
+export declare const field2Cpt: (field: Field, item: any, otherProps?: any) => React.JSX.Element | null;
+export declare const genFilterItems: (list: FilterItemProps[], dataSource?: DataSourceType) => (React.JSX.Element | null)[];
+export declare const getStoredFilterOrder: (componentId: string) => any;
+export declare const saveFilterOrder: (componentId: string, order: any) => void;

package/lib/components/dataSourceComponents/dataSourceTable/filter/utils.js

@@ -0,0 +1,188 @@
+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/filter/utils.tsx
+var utils_exports = {};
+__export(utils_exports, {
+  field2Cpt: () => field2Cpt,
+  genFilterItems: () => genFilterItems,
+  genGetField: () => genGetField,
+  getStoredFilterOrder: () => getStoredFilterOrder,
+  saveFilterOrder: () => saveFilterOrder
+});
+module.exports = __toCommonJS(utils_exports);
+var import_react = __toESM(require("react"));
+var import_utils = require("@pisell/utils");
+var import_fields = require("../../fields");
+var genGetField = (dataSource) => {
+  const { fields = [] } = dataSource || {};
+  const fieldMap = fields.reduce((acc, field) => {
+    acc[field.name] = field;
+    return acc;
+  }, {});
+  return (key) => {
+    return fieldMap[key];
+  };
+};
+var fieldType2FilterMap = {
+  Checkbox: "FormItemSelect",
+  ColorPicker: "FormItemInput",
+  DatePicker: "FormItemDateRangePicker",
+  Input: "FormItemInput",
+  Radio: "FormItemSelect",
+  Select: "FormItemSelect",
+  Percent: "FormItemPercent",
+  InputNumber: "FormItemInputNumber",
+  "Input.JSON": "FormItemInput",
+  "Input.Email": "FormItemInput",
+  "Input.URL": "FormItemInput",
+  "Input.Password": "FormItemInput",
+  "Radio.Group": "FormItemSelect",
+  "Checkbox.Group": "FormItemSelect",
+  "Translation": "FormItemTranslation"
+};
+var getCptProps = (field, cptType, item) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  let props = ((_a = field == null ? void 0 : field.uiSchema) == null ? void 0 : _a["x-component-props"]) || {};
+  props.style = {
+    ...(props == null ? void 0 : props.style) || {},
+    width: "200px",
+    margin: 0
+  };
+  props.placeholder = item.label;
+  props.allowClear = true;
+  if (cptType === "FormItemSelect") {
+    props.mode = "multiple";
+    props.showSearch = true;
+    props.optionFilterProp = "label";
+  }
+  if (["Select", "Radio.Group", "Checkbox.Group"].includes(
+    (_b = field == null ? void 0 : field.uiSchema) == null ? void 0 : _b["x-component"]
+  ) && (((_d = (_c = field == null ? void 0 : field.uiSchema) == null ? void 0 : _c.enum) == null ? void 0 : _d.length) || 0) > 0) {
+    if (["Radio.Group", "Checkbox.Group"].includes(
+      (_e = field == null ? void 0 : field.uiSchema) == null ? void 0 : _e["x-component"]
+    )) {
+      props.direction = "horizontal";
+    } else {
+      props.showSearch = true;
+      props.optionFilterProp = "label";
+    }
+    props.options = (_f = field == null ? void 0 : field.uiSchema) == null ? void 0 : _f.enum;
+  }
+  if (((_g = field == null ? void 0 : field.uiSchema) == null ? void 0 : _g["x-component"]) === "ColorPicker") {
+    props.defaultValue = (_h = field == null ? void 0 : field.uiSchema) == null ? void 0 : _h.default;
+  }
+  if (cptType === "DateRangePicker") {
+    props.style = {
+      ...(props == null ? void 0 : props.style) || {},
+      width: "240px"
+    };
+  }
+  if (((_i = field == null ? void 0 : field.uiSchema) == null ? void 0 : _i["x-component"]) === "Checkbox" && cptType === "Select") {
+    props.mode = void 0;
+    props.allowClear = true;
+    props.options = [
+      {
+        label: "是",
+        value: true
+      },
+      {
+        label: "否",
+        value: false
+      }
+    ];
+  }
+  props = {
+    ...props,
+    ...((_j = item == null ? void 0 : item.other) == null ? void 0 : _j.fieldProps) || {}
+  };
+  return props;
+};
+var field2Cpt = (field, item, otherProps) => {
+  const { isCustom, type: configType } = item;
+  const { uiSchema } = field || {};
+  const { "x-component": xComponent } = uiSchema || {};
+  let cptType = fieldType2FilterMap[xComponent];
+  if (isCustom) {
+    cptType = configType;
+  }
+  const Cpt = import_fields.formFieldMap[cptType];
+  if (!Cpt) {
+    return null;
+  }
+  const props = getCptProps(field, cptType, item);
+  const style = (0, import_utils.isFunction)(otherProps == null ? void 0 : otherProps.style) ? otherProps == null ? void 0 : otherProps.style(props.style) : (otherProps == null ? void 0 : otherProps.style) ? { ...props.style, ...otherProps == null ? void 0 : otherProps.style } : props.style;
+  return /* @__PURE__ */ import_react.default.createElement(
+    Cpt,
+    {
+      ...props,
+      label: item.label,
+      name: item.name || item.value,
+      ...otherProps,
+      style
+    }
+  );
+};
+var genFilterItems = (list, dataSource) => {
+  return list.map((item) => {
+    if (!item) {
+      return null;
+    }
+    const { name } = item;
+    const getField = genGetField(dataSource);
+    const field = getField(name);
+    const cptDom = field2Cpt(field, item);
+    return cptDom;
+  });
+};
+var FILTER_STORAGE_KEY = "filter-setting-";
+var getStorageKey = (componentId) => `${FILTER_STORAGE_KEY}${componentId}`;
+var getStoredFilterOrder = (componentId) => {
+  try {
+    const stored = localStorage.getItem(getStorageKey(componentId));
+    return stored ? JSON.parse(stored) : null;
+  } catch (e) {
+    console.error("Failed to parse stored filter order:", e);
+    return null;
+  }
+};
+var saveFilterOrder = (componentId, order) => {
+  try {
+    localStorage.setItem(getStorageKey(componentId), JSON.stringify(order));
+  } catch (e) {
+    console.error("Failed to save filter order:", e);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  field2Cpt,
+  genFilterItems,
+  genGetField,
+  getStoredFilterOrder,
+  saveFilterOrder
+});

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

@@ -0,0 +1,11 @@
+import { ColumnType } from 'antd/es/table';
+export declare type Column = ColumnType<{
+    fieldComponent: string;
+}>;
+declare type UseColumnsProps = {
+    columns: Column[];
+    fields?: any[];
+    actionsColumns?: any[];
+};
+declare const useColumns: ({ columns, fields, actionsColumns, }: UseColumnsProps) => Column[];
+export default useColumns;

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

@@ -0,0 +1,90 @@
+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/useColumns.tsx
+var useColumns_exports = {};
+__export(useColumns_exports, {
+  default: () => useColumns_default
+});
+module.exports = __toCommonJS(useColumns_exports);
+var import_react = __toESM(require("react"));
+var import_fields = require("../../fields");
+var genFieldProps = (field, fieldProps) => {
+  let props = {
+    renderMode: "tableView",
+    noStyle: true
+  };
+  if (!field)
+    return props;
+  if (["Select", "Radio.Group", "Checkbox.Group"].includes(
+    field.uiSchema["x-component"]
+  ) && field.uiSchema.enum.length > 0) {
+    if (["Radio.Group", "Checkbox.Group"].includes(field.uiSchema["x-component"])) {
+      props.direction = "horizontal";
+    }
+    props.options = field.uiSchema.enum;
+  }
+  props = {
+    ...props,
+    ...fieldProps || {}
+  };
+  return props;
+};
+var useColumns = ({
+  columns,
+  fields,
+  actionsColumns
+}) => {
+  const fieldMap = (0, import_react.useMemo)(() => {
+    if (!fields)
+      return {};
+    return fields.reduce((acc, field) => {
+      acc[field.name] = field;
+      return acc;
+    }, {});
+  }, [fields]);
+  return (0, import_react.useMemo)(() => {
+    if (Object.keys(fieldMap).length === 0)
+      return [];
+    return columns.map((column) => {
+      var _a;
+      const field = fieldMap[column == null ? void 0 : column.dataIndex];
+      const title = (column == null ? void 0 : column.title) || (field == null ? void 0 : field.title);
+      const FieldComponent = (0, import_fields.getFieldComponent)(column == null ? void 0 : column.fieldComponent) || "div";
+      const fieldProps = genFieldProps(field, (_a = column.other) == null ? void 0 : _a.fieldProps);
+      return {
+        ...column,
+        title,
+        render: (text) => {
+          return /* @__PURE__ */ import_react.default.createElement(FieldComponent, { ...fieldProps, value: text });
+        }
+      };
+    }).concat(actionsColumns || []);
+  }, [columns, fieldMap, actionsColumns]);
+};
+var useColumns_default = useColumns;

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare const useDataSourceKey: () => {
+    dataSourceKey: string | undefined;
+    dataSourceKeyRef: import("react").MutableRefObject<string | undefined>;
+};
+export default useDataSourceKey;