doui-react 1.0.0

package/es/table/component/link.d.ts

@@ -0,0 +1,2 @@
+import { ComponentProps } from './wrapper';
+export declare function Link({ column, children, ...props }: ComponentProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/es/table/component/link.js

@@ -0,0 +1,20 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["column", "children"];
+import { useTableContext } from "./..";
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+export function Link(_ref) {
+  var column = _ref.column,
+    children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var context = useTableContext();
+  var params = _objectSpread(_objectSpread({}, props), context);
+  return _jsx("a", {
+    onClick: function onClick(e) {
+      var _column$onClick;
+      e.preventDefault();
+      (_column$onClick = column.onClick) === null || _column$onClick === void 0 || _column$onClick.call(column, params);
+    },
+    children: children
+  });
+}

package/es/table/component/sort.d.ts

@@ -0,0 +1,6 @@
+import { Column } from '../type';
+export declare function getSortColumn({ dataIndex, sort }: Column): {
+    sorter: import("antd/lib/table/interface").CompareFn<any>;
+} | {
+    sorter: (a: any, b: any) => any;
+};

package/es/table/component/sort.js

@@ -0,0 +1,17 @@
+import { sorter as _sorter } from "../../api";
+import _ from 'lodash';
+export function getSortColumn(_ref) {
+  var _ref$dataIndex = _ref.dataIndex,
+    dataIndex = _ref$dataIndex === void 0 ? '' : _ref$dataIndex,
+    sort = _ref.sort;
+  if (_.isFunction(sort)) {
+    return {
+      sorter: sort
+    };
+  }
+  return {
+    sorter: function sorter(a, b) {
+      return _sorter(a[dataIndex], b[dataIndex]);
+    }
+  };
+}

package/es/table/component/switch.d.ts

@@ -0,0 +1,2 @@
+import { ComponentProps } from './wrapper';
+export declare function Switch({ column, children, ...props }: ComponentProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/es/table/component/switch.js

@@ -0,0 +1,27 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["column", "children"];
+import { executeFunction } from "../../api";
+import { Switch as ESwitch } from "../../switch";
+import { useTableContext } from "./..";
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+export function Switch(_ref) {
+  var column = _ref.column,
+    children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var disabled = column.disabled,
+    tooltip = column.tooltip,
+    onClick = column.onClick;
+  var context = useTableContext();
+  var params = _objectSpread(_objectSpread({}, props), context);
+  return _jsx(ESwitch, {
+    value: children,
+    onChange: function onChange(value) {
+      return onClick === null || onClick === void 0 ? void 0 : onClick(_objectSpread(_objectSpread({}, params), {}, {
+        current: value
+      }));
+    },
+    disabled: executeFunction(disabled, params),
+    tooltip: executeFunction(tooltip, params)
+  });
+}

package/es/table/component/table-body.d.ts

@@ -0,0 +1,6 @@
+import { DataSource, TableProps } from "..";
+interface TableBodyProps extends TableProps {
+    dataSource: DataSource;
+}
+export declare function TableBody({ children, footer, autoCollectFormValue, ...props }: TableBodyProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/es/table/component/table-body.js

@@ -0,0 +1,88 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+var _excluded = ["children", "footer", "autoCollectFormValue"];
+import { getClassName } from "../../api";
+import { useFormContext } from "../../form";
+import { useDeepEffect } from "../../hooks";
+import { useTableContext } from "./..";
+import { Table as AntdTable } from 'antd';
+import _ from 'lodash';
+import { useToggle, useUnmount } from 'react-use';
+import { getTableFormInitialValues, updateDataSourceByFormValues } from "./utils";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
+/**
+ * 当 dataSource 数据量过大时，直接作为 formValue 有可能导致性能问题，
+ * 所以需要从 dataSource 中，通过 getTableFormInitialValues 方法提取出 formValue，减少冗余数据，
+ * 故而当 formValue 发生变化时，需要通过 updateDataSourceByFormValues 方法更新 dataSource 中对应的数据。
+ */
+function useTableFormValue(_ref) {
+  var columns = _ref.columns,
+    dataSource = _ref.dataSource;
+  var _useTableContext = useTableContext(),
+    rowKey = _useTableContext.rowKey,
+    editorValueKey = _useTableContext.editorValueKey;
+  var _useFormContext = useFormContext(),
+    form = _useFormContext.form,
+    values = _useFormContext.values,
+    __removeCollect__ = _useFormContext.__removeCollect__;
+  var formValues = _.get(values, editorValueKey);
+  var _useToggle = useToggle(true),
+    _useToggle2 = _slicedToArray(_useToggle, 2),
+    needUpdateDataSource = _useToggle2[0],
+    setNeedUpdateDataSource = _useToggle2[1];
+  useDeepEffect(function () {
+    if (!formValues || !needUpdateDataSource) {
+      setNeedUpdateDataSource(true);
+      return;
+    }
+    updateDataSourceByFormValues(formValues, dataSource);
+  }, [formValues]);
+  useDeepEffect(function () {
+    var initialValues = getTableFormInitialValues({
+      rowKey: rowKey,
+      columns: columns,
+      dataSource: dataSource
+    });
+    if (!initialValues) {
+      return;
+    }
+    setNeedUpdateDataSource(false);
+    form.setValue(editorValueKey, initialValues);
+  }, [dataSource]);
+
+  // 删除当前 Table 下的 Items
+  useUnmount(function () {
+    return __removeCollect__(editorValueKey, {
+      isTableEditor: true
+    });
+  });
+}
+
+/**
+ * 动态渲染 hook
+ */
+function CollectFormValue(props) {
+  useTableFormValue(props);
+  return null;
+}
+export function TableBody(_ref2) {
+  var children = _ref2.children,
+    footer = _ref2.footer,
+    _ref2$autoCollectForm = _ref2.autoCollectFormValue,
+    autoCollectFormValue = _ref2$autoCollectForm === void 0 ? true : _ref2$autoCollectForm,
+    props = _objectWithoutProperties(_ref2, _excluded);
+  var _useFormContext2 = useFormContext(),
+    form = _useFormContext2.form;
+  return _jsxs(_Fragment, {
+    children: [_jsx("div", {
+      className: getClassName('table-header'),
+      children: children
+    }), _jsx(AntdTable, _objectSpread({
+      tableLayout: "auto"
+    }, props)), _jsx("div", {
+      className: getClassName('table-footer'),
+      children: footer
+    }), autoCollectFormValue && form && _jsx(CollectFormValue, _objectSpread({}, props))]
+  });
+}

package/es/table/component/table.d.ts

@@ -0,0 +1,10 @@
+import { DataSource, TableContext } from "..";
+import { TableProps } from '../type';
+interface UseTableReturn extends TableProps {
+    useFormWrapper: boolean;
+    context: TableContext;
+    dataSource: DataSource;
+}
+export declare function useTable({ onRowClick, width, emptyText, ...restProps }: TableProps): UseTableReturn;
+export declare function Table(props: TableProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/es/table/component/table.js

@@ -0,0 +1,235 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+var _excluded = ["rowKey", "loading", "columns", "dataSource", "editorValueKey"],
+  _excluded2 = ["onlyLoading"],
+  _excluded3 = ["onRowClick", "width", "emptyText"],
+  _excluded4 = ["useFormWrapper", "context", "maxHeight"];
+import { executeFunction } from "../../api";
+import { Empty } from "../../empty";
+import { Form, useFormContext } from "../../form";
+import { useListOperation } from "../../hooks";
+import { TableProvider, useSearchColumn } from "./..";
+import _ from 'lodash';
+import { useEffect, useState } from 'react';
+import { useSetState } from 'react-use';
+import styles from "../style";
+import { TableBody } from "./table-body";
+import { generateColumns, getRowSelection, getTableAndFormProps, isUseFormWrapper } from "./utils";
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+function useContext(_ref) {
+  var outerContext = _ref.context,
+    initialContext = _ref.initialContext;
+  var _useSetState = useSetState({}),
+    _useSetState2 = _slicedToArray(_useSetState, 2),
+    context = _useSetState2[0],
+    setContext = _useSetState2[1];
+  var contexts = _objectSpread(_objectSpread(_objectSpread({}, context), outerContext), {}, {
+    setContext: setContext
+  });
+  function getInitialContext(_x) {
+    return _getInitialContext.apply(this, arguments);
+  }
+  function _getInitialContext() {
+    _getInitialContext = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(params) {
+      var context;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return executeFunction(initialContext, params);
+          case 2:
+            context = _context.sent;
+            setContext(context);
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return _getInitialContext.apply(this, arguments);
+  }
+  return {
+    contexts: contexts,
+    getInitialContext: getInitialContext
+  };
+}
+function useInit(_ref2) {
+  var _ref2$rowKey = _ref2.rowKey,
+    rowKey = _ref2$rowKey === void 0 ? 'id' : _ref2$rowKey,
+    originLoading = _ref2.loading,
+    columns = _ref2.columns,
+    data = _ref2.dataSource,
+    _ref2$editorValueKey = _ref2.editorValueKey,
+    editorValueKey = _ref2$editorValueKey === void 0 ? 'tableEditorValues' : _ref2$editorValueKey,
+    restProps = _objectWithoutProperties(_ref2, _excluded);
+  var _useFormContext = useFormContext(),
+    form = _useFormContext.form;
+  var _useState = useState(true),
+    _useState2 = _slicedToArray(_useState, 2),
+    loading = _useState2[0],
+    setLoading = _useState2[1];
+  var _useState3 = useState([]),
+    _useState4 = _slicedToArray(_useState3, 2),
+    dataSource = _useState4[0],
+    setDataSource = _useState4[1];
+  var _useState5 = useState([]),
+    _useState6 = _slicedToArray(_useState5, 2),
+    selectedRowKeys = _useState6[0],
+    _setSelectedRowKeys = _useState6[1];
+  var _useContext = useContext(restProps),
+    contexts = _useContext.contexts,
+    getInitialContext = _useContext.getInitialContext;
+  var operation = useListOperation({
+    value: dataSource,
+    onChange: setDataSource
+  });
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  useEffect(function () {
+    return void refresh();
+  }, [data]);
+  var context = _objectSpread(_objectSpread({}, contexts), {}, {
+    refresh: refresh,
+    dataSource: dataSource,
+    setDataSource: setDataSource,
+    selectedRowKeys: selectedRowKeys,
+    setSelectedRowKeys: function setSelectedRowKeys() {
+      var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      return _setSelectedRowKeys(keys);
+    },
+    operation: operation,
+    rowKey: rowKey,
+    editorValueKey: editorValueKey
+  });
+  function refresh() {
+    return _refresh.apply(this, arguments);
+  }
+  function _refresh() {
+    _refresh = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var _ref3,
+        onlyLoading,
+        params,
+        _yield$Promise$all,
+        _yield$Promise$all2,
+        res,
+        _args2 = arguments;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _ref3 = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {}, onlyLoading = _ref3.onlyLoading, params = _objectWithoutProperties(_ref3, _excluded2);
+            setLoading(true);
+            if (!onlyLoading) {
+              _context2.next = 4;
+              break;
+            }
+            return _context2.abrupt("return");
+          case 4:
+            _context2.prev = 4;
+            _context2.next = 7;
+            return Promise.all([executeFunction(data, params), getInitialContext(params)]);
+          case 7:
+            _yield$Promise$all = _context2.sent;
+            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 1);
+            res = _yield$Promise$all2[0];
+            setDataSource(res || []);
+          case 11:
+            _context2.prev = 11;
+            setLoading(false);
+            return _context2.finish(11);
+          case 14:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[4,, 11, 14]]);
+    }));
+    return _refresh.apply(this, arguments);
+  }
+  var rowSelection = getRowSelection({
+    rowKey: rowKey,
+    columns: columns,
+    context: context
+  });
+  var useFormWrapper = isUseFormWrapper({
+    columns: columns,
+    context: context,
+    form: form
+  });
+  return {
+    rowKey: rowKey,
+    loading: originLoading !== null && originLoading !== void 0 ? originLoading : loading,
+    rowSelection: rowSelection,
+    dataSource: dataSource,
+    context: context,
+    useFormWrapper: useFormWrapper
+  };
+}
+export function useTable(_ref4) {
+  var onRowClick = _ref4.onRowClick,
+    width = _ref4.width,
+    emptyText = _ref4.emptyText,
+    restProps = _objectWithoutProperties(_ref4, _excluded3);
+  var params = useInit(restProps);
+  var _useSearchColumn = useSearchColumn(),
+    getSearchColumn = _useSearchColumn.getSearchColumn;
+  var columns = generateColumns({
+    columns: _.reject(restProps.columns, {
+      type: 'selection'
+    }),
+    getSearchColumn: getSearchColumn
+  });
+  return _objectSpread(_objectSpread(_objectSpread({
+    onRow: function onRow(record) {
+      var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      return {
+        onClick: function onClick() {
+          return onRowClick === null || onRowClick === void 0 ? void 0 : onRowClick(_objectSpread(_objectSpread({}, params.context), {}, {
+            record: record,
+            index: index
+          }));
+        }
+      };
+    },
+    locale: {
+      emptyText: _jsx(Empty, {
+        description: emptyText
+      })
+    },
+    scroll: {
+      x: width !== null && width !== void 0 ? width : true
+    }
+  }, restProps), params), {}, {
+    columns: columns
+  });
+}
+export function Table(props) {
+  var _getTableAndFormProps = getTableAndFormProps(props),
+    formProps = _getTableAndFormProps.formProps,
+    tableProps = _getTableAndFormProps.tableProps;
+  var _useTable = useTable(tableProps),
+    useFormWrapper = _useTable.useFormWrapper,
+    context = _useTable.context,
+    maxHeight = _useTable.maxHeight,
+    restProps = _objectWithoutProperties(_useTable, _excluded4);
+  function render() {
+    if (useFormWrapper) {
+      return _jsx(Form, _objectSpread(_objectSpread({
+        css: styles.wrapper(maxHeight)
+      }, formProps), {}, {
+        loading: false,
+        children: _jsx(TableBody, _objectSpread({}, restProps))
+      }));
+    }
+    return _jsx("div", {
+      css: styles.wrapper(maxHeight),
+      className: formProps.className,
+      style: formProps.style,
+      children: _jsx(TableBody, _objectSpread({}, restProps))
+    });
+  }
+  return _jsx(TableProvider, _objectSpread(_objectSpread({}, context), {}, {
+    children: render()
+  }));
+}

package/es/table/component/time.d.ts

@@ -0,0 +1,2 @@
+import { ComponentProps } from './wrapper';
+export declare function Time({ column, children }: ComponentProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/es/table/component/time.js

@@ -0,0 +1,12 @@
+import moment from 'moment-timezone';
+import { Fragment as _Fragment, jsx as _jsx } from "@emotion/react/jsx-runtime";
+var defaultFormat = 'YYYY-MM-DD hh:mm:ss A';
+export function Time(_ref) {
+  var column = _ref.column,
+    children = _ref.children;
+  var timeFormat = column.timeFormat;
+  var format = timeFormat || defaultFormat;
+  return _jsx(_Fragment, {
+    children: moment(+children).format(format)
+  });
+}

package/es/table/component/utils.d.ts

@@ -0,0 +1,120 @@
+/// <reference types="react" />
+import { FormInstance, FormProps } from "../../form";
+import { TableRowSelection } from 'antd/lib/table/interface';
+import { Column, DataSource, GetSearchColumn, TableContext, TableProps } from '../type';
+import { Actions } from './actions';
+import { Editor } from './editor';
+import { Link } from './link';
+import { Switch } from './switch';
+import { Time } from './time';
+interface GenerateColumnsProps extends TableProps {
+    getSearchColumn: GetSearchColumn;
+}
+export declare const componentMap: {
+    time: typeof Time;
+    link: typeof Link;
+    switch: typeof Switch;
+    actions: typeof Actions;
+    selection: string;
+    editor: typeof Editor;
+    default: (props: any) => any;
+};
+export declare function generateColumns({ columns, getSearchColumn }: GenerateColumnsProps): {
+    render: (current: any, record: Record<string, any>, index: number) => import("react").ReactNode;
+    dataIndex?: string | undefined;
+    type?: "link" | "time" | "switch" | "actions" | "selection" | "editor" | undefined;
+    width?: string | number | undefined;
+    minWidth?: string | number | undefined;
+    maxWidth?: string | number | undefined;
+    rows?: number | undefined;
+    timeFormat?: string | undefined;
+    disabled?: boolean | ((props: import("../type").CommonProps) => boolean) | undefined;
+    tooltip?: import("react").ReactNode | ((props: import("../type").CommonProps) => import("react").ReactNode);
+    onClick?(props: import("../type").CommonProps): any;
+    search?: boolean | string[] | ((props: import("../type").CustomFilterProps) => boolean) | undefined;
+    placeholder?: string | undefined;
+    sort?: boolean | import("antd/lib/table/interface").CompareFn<any> | {
+        compare?: import("antd/lib/table/interface").CompareFn<any> | undefined;
+        multiple?: number | undefined;
+    } | undefined;
+    filters?: (boolean | import("react").Key | import("antd/lib/table/interface").ColumnFilterItem)[] | undefined;
+    filterBy?: string[] | ((props: import("../type").CustomFilterProps) => boolean) | undefined;
+    actions?: import("../type").ActionProps[] | ((props: import("../type").CommonProps) => import("../type").ActionProps[]) | undefined;
+    editorProps?: import("../../form").FormItemProps | ((props: import("../type").CommonProps) => import("../../form").FormItemProps) | undefined;
+    title?: import("antd/lib/table/interface").ColumnTitle<any>;
+    key?: import("react").Key | undefined;
+    className?: string | undefined;
+    fixed?: import("rc-table/lib/interface").FixedType | undefined;
+    align?: import("rc-table/lib/interface").AlignType | undefined;
+    colSpan?: number | undefined;
+    rowSpan?: number | undefined;
+    responsive?: import("antd/lib/_util/responsiveObserve").Breakpoint[] | undefined;
+    shouldCellUpdate?: ((record: any, prevRecord: any) => boolean) | undefined;
+    onCell?: import("rc-table/lib/interface").GetComponentProps<any> | undefined;
+    onCellClick?: ((record: any, e: import("react").MouseEvent<HTMLElement, MouseEvent>) => void) | undefined;
+    onHeaderCell?: import("rc-table/lib/interface").GetComponentProps<import("rc-table/lib/interface").ColumnType<any> | import("rc-table/lib/interface").ColumnGroupType<any>> | undefined;
+    sorter?: boolean | import("antd/lib/table/interface").CompareFn<any> | {
+        compare?: import("antd/lib/table/interface").CompareFn<any> | undefined;
+        multiple?: number | undefined;
+    } | undefined;
+    sortOrder?: import("antd/lib/table/interface").SortOrder | undefined;
+    defaultSortOrder?: import("antd/lib/table/interface").SortOrder | undefined;
+    sortDirections?: import("antd/lib/table/interface").SortOrder[] | undefined;
+    showSorterTooltip?: boolean | import("antd").TooltipProps | undefined;
+    filtered?: boolean | undefined;
+    filterDropdown?: import("react").ReactNode | ((props: import("antd/lib/table/interface").FilterDropdownProps) => import("react").ReactNode);
+    filterMultiple?: boolean | undefined;
+    filteredValue?: import("antd/lib/table/interface").FilterValue | null | undefined;
+    defaultFilteredValue?: import("antd/lib/table/interface").FilterValue | null | undefined;
+    filterIcon?: import("react").ReactNode | ((filtered: boolean) => import("react").ReactNode);
+    filterMode?: "menu" | "tree" | undefined;
+    filterSearch?: import("antd/lib/table/interface").FilterSearchType<import("antd/lib/table/interface").ColumnFilterItem> | undefined;
+    onFilter?: ((value: boolean | import("react").Key, record: any) => boolean) | undefined;
+    filterDropdownVisible?: boolean | undefined;
+    filterDropdownOpen?: boolean | undefined;
+    onFilterDropdownVisibleChange?: ((visible: boolean) => void) | undefined;
+    onFilterDropdownOpenChange?: ((open: boolean) => void) | undefined;
+    filterResetToDefaultFilteredValue?: boolean | undefined;
+    columnWidth?: string | number | undefined;
+    onChange?: ((selectedRowKeys: import("react").Key[], selectedRows: any[], info: {
+        type: import("antd/lib/table/interface").RowSelectMethod;
+    }) => void) | undefined;
+    onSelect?: import("antd/lib/table/interface").SelectionSelectFn<any> | undefined;
+    preserveSelectedRowKeys?: boolean | undefined;
+    selectedRowKeys?: import("react").Key[] | undefined;
+    defaultSelectedRowKeys?: import("react").Key[] | undefined;
+    getCheckboxProps?: ((record: any) => Partial<Omit<import("antd").CheckboxProps, "defaultChecked" | "checked">>) | undefined;
+    onSelectMultiple?: ((selected: boolean, selectedRows: any[], changeRows: any[]) => void) | undefined;
+    onSelectAll?: ((selected: boolean, selectedRows: any[], changeRows: any[]) => void) | undefined;
+    onSelectInvert?: ((selectedRowKeys: import("react").Key[]) => void) | undefined;
+    onSelectNone?: (() => void) | undefined;
+    selections?: boolean | import("antd/lib/table/hooks/useSelection").INTERNAL_SELECTION_ITEM[] | undefined;
+    hideSelectAll?: boolean | undefined;
+    columnTitle?: import("react").ReactNode;
+    checkStrictly?: boolean | undefined;
+    renderCell?: ((value: boolean, record: any, index: number, originNode: import("react").ReactNode) => import("react").ReactNode | import("rc-table/lib/interface").RenderedCell<any>) | undefined;
+}[];
+interface RowSelectionProps {
+    rowKey: string;
+    columns: Column[];
+    context: TableContext;
+}
+export declare function getRowSelection({ rowKey, columns, context }: RowSelectionProps): TableRowSelection<any> | undefined;
+export declare function getTableAndFormProps(props: TableProps): {
+    formProps: FormProps;
+    tableProps: TableProps;
+};
+interface UseFormWrapperProps {
+    columns: Column[];
+    context: TableContext;
+    form: FormInstance;
+}
+export declare function isUseFormWrapper({ columns, context, form }: UseFormWrapperProps): boolean;
+interface TableFormInitialValuesProps {
+    rowKey: string;
+    columns: Column[];
+    dataSource: DataSource;
+}
+export declare function getTableFormInitialValues({ rowKey, columns, dataSource }: TableFormInitialValuesProps): Pick<any, string>[] | undefined;
+export declare function updateDataSourceByFormValues(formValues: DataSource, dataSource: DataSource): void;
+export {};