ztxkui 4.2.23-2 → 4.2.23-21

package/dist/components/ProForm/items.js

@@ -0,0 +1,136 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { memo } from 'react';
+import { Form } from 'antd';
+import classNames from 'classnames';
+function Items(props) {
+    var items = props.items, itemClassName = props.itemClassName;
+    return (React.createElement(React.Fragment, null, items.map(function (item, index) {
+        var _a;
+        var render = item.render, isRequire = item.isRequire, isDisplay = item.isDisplay, isChangeable = item.isChangeable, dependencies = item.dependencies, shouldUpdate = item.shouldUpdate, disabled = item.disabled, noBorder = item.noBorder, width = item.width, shouldUpdateNames = item.shouldUpdateNames, shouldUpdateClear = item.shouldUpdateClear, resetItem = __rest(item, ["render", "isRequire", "isDisplay", "isChangeable", "dependencies", "shouldUpdate", "disabled", "noBorder", "width", "shouldUpdateNames", "shouldUpdateClear"]);
+        // 处理配置相关逻辑 配置优先代码
+        // 传入了是否必填配置
+        if (isRequire !== undefined) {
+            var isRequireBoolean = !!isRequire;
+            var rules = Array.isArray(resetItem.rules) ? resetItem.rules : [];
+            // 是否之前就传入了必填非必填逻辑
+            var requiredIndex = rules.findIndex(function (rule) {
+                if (typeof rule === 'function') {
+                    return false;
+                }
+                return (rule === null || rule === void 0 ? void 0 : rule.required) === true || (rule === null || rule === void 0 ? void 0 : rule.required) === false;
+            });
+            // 如果找到了 直接替换之前的规则
+            if (requiredIndex !== -1) {
+                var message = (_a = rules[requiredIndex]) === null || _a === void 0 ? void 0 : _a.message;
+                rules.splice(requiredIndex, 1, {
+                    required: isRequireBoolean,
+                    message: message,
+                });
+            }
+            else {
+                rules.unshift({
+                    required: isRequireBoolean,
+                    message: resetItem.label + " \u672A\u586B!",
+                });
+            }
+            resetItem.rules = rules;
+        }
+        // 传入了是否展示配置
+        if (isDisplay !== undefined) {
+            var isDisplayBoolean = !!isDisplay;
+            if (!isDisplayBoolean) {
+                return null;
+            }
+        }
+        // 传入了是否禁用配置
+        var itemProps = {
+            disabled: disabled,
+        };
+        if (isChangeable !== undefined) {
+            itemProps = {
+                disabled: !isChangeable,
+            };
+        }
+        var itemClasses = classNames('pro-form__item', itemClassName, {
+            'pro-form__item--disabled': itemProps.disabled,
+            'pro-form__item--noborder': noBorder,
+            // 'pro-form__item--nolabel': noLabel,
+            // 'pro-form__item--nolabelshowbg': noLabelShowBg,
+        });
+        if (dependencies) {
+            return (React.createElement(ItemWrap, { key: item.name, width: width },
+                React.createElement(Form.Item, { dependencies: dependencies, noStyle: true }, function (formInstance) {
+                    return (React.createElement(Form.Item, __assign({}, resetItem, { className: itemClasses }), render(itemProps, formInstance)));
+                })));
+        }
+        if (shouldUpdate || shouldUpdateNames) {
+            var key = typeof item.name === 'string' ? item.name : index + '';
+            var shouldUpdateHandle = shouldUpdateNames
+                ? function (prevValues, curValues, info) {
+                    for (var i = 0; i < shouldUpdateNames.length; i++) {
+                        var shouldUpdateName = shouldUpdateNames[i];
+                        if (prevValues[shouldUpdateName] !== curValues[shouldUpdateName]) {
+                            return true;
+                        }
+                    }
+                    if (typeof shouldUpdate === 'function') {
+                        return shouldUpdate(prevValues, curValues, info);
+                    }
+                    if (typeof shouldUpdate === 'boolean') {
+                        return shouldUpdate;
+                    }
+                    return false;
+                }
+                : shouldUpdate;
+            return (React.createElement(ItemWrap, { key: key, width: width },
+                React.createElement(Form.Item, { shouldUpdate: shouldUpdateHandle, noStyle: true }, function (formInstance) {
+                    return item.name ? (React.createElement(Form.Item, __assign({}, resetItem, { className: itemClasses }), render(itemProps, formInstance))) : (render(itemProps, formInstance));
+                })));
+        }
+        return (React.createElement(ItemWrap, { key: item.name, width: width },
+            React.createElement(Form.Item, __assign({}, resetItem, { className: itemClasses }), render(itemProps))));
+    })));
+}
+function getWidthStr(width) {
+    switch (width) {
+        case 'half':
+            return '16.66%';
+        case 'all':
+            return '100%';
+        case 'double':
+            return '66.66%';
+        case 'halfAll':
+            return '50%';
+        default:
+            return '33.33%';
+    }
+}
+function ItemWrap(props) {
+    var className = props.className, children = props.children, width = props.width;
+    var itemClasses = classNames('pro-form__item--wrap', className);
+    return (React.createElement("div", { className: itemClasses, style: {
+            width: getWidthStr(width),
+        } }, children));
+}
+export default memo(Items);

package/dist/components/ProForm/search-drawer.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { ISearchLayout } from './interface';
+interface IProps {
+    visible: boolean;
+    onClose: () => void;
+    onSure: (newList: ISearchLayout[]) => void;
+    onReset: () => void;
+    dynamicList: ISearchLayout[];
+}
+declare const _default: React.NamedExoticComponent<IProps>;
+export default _default;

package/dist/components/ProForm/search-drawer.js

@@ -0,0 +1,76 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import React, { memo, useCallback, useMemo, useState, useEffect } from 'react';
+import { SettingOutlined } from '@ant-design/icons';
+import { Drawer, Button, Sortable, Checkbox } from '../../index';
+import { DndProvider } from 'react-dnd';
+import { HTML5Backend } from 'react-dnd-html5-backend';
+import update from 'immutability-helper';
+var SearchDrawer = function (_a) {
+    var visible = _a.visible, onClose = _a.onClose, onReset = _a.onReset, onSure = _a.onSure, dynamicList = _a.dynamicList;
+    var _b = useState(dynamicList), innerDynamicList = _b[0], setInnerDynamicList = _b[1];
+    useEffect(function () {
+        setInnerDynamicList(dynamicList);
+    }, [dynamicList]);
+    var checkedValues = useMemo(function () {
+        var _checkedValues = [];
+        innerDynamicList.forEach(function (item) {
+            if (item.show) {
+                _checkedValues.push(item.name);
+            }
+        });
+        return _checkedValues;
+    }, [innerDynamicList]);
+    /**移动事件 */
+    var onMoveItem = useCallback(function (dragIndex, hoverIndex) {
+        setInnerDynamicList(function (preDynamicList) {
+            var dragCard = preDynamicList[dragIndex];
+            var currentList = update(preDynamicList, {
+                $splice: [
+                    [dragIndex, 1],
+                    [hoverIndex, 0, dragCard],
+                ],
+            });
+            return currentList;
+        });
+    }, []);
+    /**确认事件 */
+    var onSureHandle = useCallback(function () {
+        onSure && onSure(innerDynamicList);
+    }, [onSure, innerDynamicList]);
+    var onCheckboxChange = function (checkedValues) {
+        var newDynamicList = innerDynamicList.map(function (item) { return (__assign({}, item)); }) || [];
+        newDynamicList.forEach(function (item) {
+            if (!checkedValues.find(function (value) { return value === item.name; })) {
+                item.show = false;
+            }
+            else {
+                item.show = true;
+            }
+        });
+        setInnerDynamicList(newDynamicList);
+    };
+    /**底部按钮 */
+    var renderFooter = function () { return (React.createElement(React.Fragment, null,
+        React.createElement(Button, { type: "default", onClick: onClose }, "\u53D6\u6D88"),
+        React.createElement(Button, { type: "default", onClick: onReset }, "\u91CD\u7F6E"),
+        React.createElement(Button, { type: "primary", onClick: onSureHandle }, "\u786E\u5B9A"))); };
+    return (React.createElement(Drawer, { className: "search-drawer", title: React.createElement("div", null,
+            React.createElement(SettingOutlined, { style: { fontSize: 16 } }),
+            React.createElement("span", { className: "search-drawer--title-text" },
+                "\u67E5\u8BE2\u6761\u4EF6\u81EA\u5B9A\u4E49",
+                React.createElement("span", null, "\uFF08\u62D6\u62FD\u6392\u5E8F\uFF09"))), width: 290, placement: "right", visible: visible, closable: false, maskClosable: false, footer: renderFooter() },
+        React.createElement(DndProvider, { backend: HTML5Backend, context: window },
+            React.createElement(Checkbox.Group, { value: checkedValues, onChange: onCheckboxChange }, innerDynamicList.map(function (item, index) { return (React.createElement(Sortable, { key: item.name, type: "search-drawer", index: index, onMoveItem: onMoveItem },
+                React.createElement(Checkbox, { value: item.name, disabled: item.disabled || item.dynamicDisabled }, item.label || item.name))); })))));
+};
+export default memo(SearchDrawer);

package/dist/components/ProForm/setting.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ISettingProps } from './interface';
+declare function Setting(props: ISettingProps): JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof Setting>;
+export default _default;

package/dist/components/ProForm/setting.js

@@ -0,0 +1,13 @@
+import React, { memo } from 'react';
+import { SettingOutlined } from '@ant-design/icons';
+import { useDrawer } from './hooks';
+import SearchDrawer from './search-drawer';
+function Setting(props) {
+    var list = props.list, initList = props.initList, showDynamicKey = props.showDynamicKey, setCurrentDynamicList = props.setCurrentDynamicList;
+    var _a = useDrawer(initList, setCurrentDynamicList, showDynamicKey), visible = _a.visible, setVisible = _a.setVisible, onClose = _a.onClose, onReset = _a.onReset, onSure = _a.onSure;
+    return (React.createElement("div", { className: "pro-form__middle" },
+        Array.isArray(list) && list.length ? (React.createElement("div", { className: "pro-form__middle--setting", onClick: function () { return setVisible(true); } },
+            React.createElement(SettingOutlined, { style: { fontSize: 18, color: '#768696' } }))) : null,
+        Array.isArray(list) && list.length ? (React.createElement(SearchDrawer, { visible: visible, onClose: onClose, onSure: onSure, onReset: onReset, dynamicList: list })) : null));
+}
+export default memo(Setting);

package/dist/components/ProFormList/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { IProps as IListProps } from '../business/NewList/list';
+import { IProps as IItemProps } from '../business/NewList/item';
+export interface IProItemProps extends IItemProps {
+    label?: React.ReactNode;
+}
+export interface IProps extends IListProps {
+    items: IProItemProps[];
+}
+declare function ProFormList(props: IProps): JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof ProFormList>;
+export default _default;

package/dist/components/ProFormList/index.js

@@ -0,0 +1,34 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { memo } from 'react';
+import FormList from '../business/NewList';
+function ProFormList(props) {
+    var items = props.items, restProps = __rest(props, ["items"]);
+    return (React.createElement(FormList, __assign({}, restProps), Array.isArray(items)
+        ? items.map(function (item, index) {
+            var _a = item.span, span = _a === void 0 ? 6 : _a, label = item.label, restItems = __rest(item, ["span", "label"]);
+            return (React.createElement(FormList.FormItem, __assign({ key: index + '' }, restItems, { span: span }), label));
+        })
+        : null));
+}
+export default memo(ProFormList);

package/dist/components/ProModal/ModalForm.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 弹出框基本布局
+ */
+import React from 'react';
+import { IProModalFormProps } from './interface';
+declare function ModalForm(props: IProModalFormProps): JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof ModalForm>;
+export default _default;

package/dist/components/ProModal/ModalForm.js

@@ -0,0 +1,32 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * 弹出框基本布局
+ */
+import React, { memo } from 'react';
+import ProForm from '../ProForm';
+function ModalForm(props) {
+    var formReset = __rest(props, []);
+    return React.createElement(ProForm, __assign({ rightWrapVisible: true }, formReset));
+}
+export default memo(ModalForm);

package/dist/components/ProModal/ModalTable.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 表格
+ */
+import React from 'react';
+import { IProModalTableProps } from './interface';
+declare function ModalTable(props: IProModalTableProps): JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof ModalTable>;
+export default _default;

package/dist/components/ProModal/ModalTable.js

@@ -0,0 +1,32 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * 表格
+ */
+import React, { memo } from 'react';
+import ProTable from '../ProTable';
+function ModalTable(props) {
+    var tableReset = __rest(props, []);
+    return React.createElement(ProTable, __assign({}, tableReset));
+}
+export default memo(ModalTable);

package/dist/components/ProModal/hooks.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+import { IProModalProps } from './interface';
+import { IFooterDom } from '../business/Footer';
+interface IUseData {
+    visible?: boolean;
+    request?: IProModalProps['request'];
+}
+export declare function useData({ visible, request }: IUseData, fetchParams: any): {
+    loading: boolean;
+    data: any;
+    setData: import("react").Dispatch<any>;
+};
+export declare function useModalForm(outsideParams?: any, formPropsDateTransform?: any, visible?: boolean): {
+    form: import("antd").FormInstance<any>;
+    initialValues: any;
+    fetchParams: any;
+    onSearchHandle: () => void;
+    onResetHandle: () => void;
+};
+export declare function useModalTable(choiceOptions: any, setData: any): {
+    innerSelectedRowKeys: any;
+    setInnerSelectedRowKeys: import("react").Dispatch<any>;
+    innerSelectedRows: any;
+    setInnerSelectedRows: import("react").Dispatch<any>;
+    onSelectedRowChange: (selectedRowKeys: React.Key[], selectedRows: any[]) => void;
+    choiceFilterHandle: (record: any, selectedRowKeys: React.Key[], selectedRows: any[]) => any;
+    onTableChange: (newData: any) => void;
+};
+export declare function useFooter(onClose: any, choiceOptions: any, data: any): {
+    footerDom: IFooterDom[];
+    onCloseHandle: () => void;
+};
+export {};

package/dist/components/ProModal/hooks.js

@@ -0,0 +1,193 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { useState, useEffect, useCallback, useMemo } from 'react';
+import { unstable_batchedUpdates } from 'react-dom';
+import { message } from '../../index';
+import { useForm } from '../ProForm';
+import { timeTransfrom } from 'ztxkutils/dist/tools';
+// 数据获取相关逻辑
+var initData = [];
+export function useData(_a, fetchParams) {
+    var visible = _a.visible, request = _a.request;
+    var _b = useState(false), loading = _b[0], setLoading = _b[1];
+    var _c = useState(initData), data = _c[0], setData = _c[1];
+    // 只有当模态框被打开时，才发送数据请求
+    useEffect(function () {
+        if (visible) {
+            setLoading(true);
+            if (request) {
+                request(fetchParams)
+                    .then(function (data) {
+                    unstable_batchedUpdates(function () {
+                        setLoading(false);
+                        setData(data);
+                    });
+                })
+                    .catch(function () {
+                    unstable_batchedUpdates(function () {
+                        setLoading(false);
+                        setData(initData);
+                    });
+                });
+            }
+        }
+    }, [visible, request, fetchParams]);
+    return {
+        loading: loading,
+        data: data,
+        setData: setData,
+    };
+}
+// 弹出框表单逻辑
+export function useModalForm(outsideParams, formPropsDateTransform, visible) {
+    if (outsideParams === void 0) { outsideParams = {}; }
+    if (formPropsDateTransform === void 0) { formPropsDateTransform = {}; }
+    var form = useForm()[0];
+    var _a = useState(outsideParams), fetchParams = _a[0], setFetchParams = _a[1];
+    // 初始化表单赋值
+    var initialValues = useMemo(function () {
+        return outsideParams;
+    }, [outsideParams]);
+    useEffect(function () {
+        if (visible) {
+            form.resetFields();
+        }
+    }, [visible, form]);
+    // 查询事件
+    var onSearchHandle = useCallback(function () {
+        var formParams = form.getFieldsValue(); // 表单数据
+        var currentParams = __assign(__assign({}, outsideParams), formParams);
+        // 将日期格式转换成数据查询时 所需要的格式
+        var newParams = timeTransfrom(__assign({ params: currentParams }, formPropsDateTransform));
+        setFetchParams(newParams);
+    }, [form, outsideParams, formPropsDateTransform]);
+    // 重置事件
+    var onResetHandle = useCallback(function () {
+        form.resetFields();
+    }, [form]);
+    return {
+        form: form,
+        initialValues: initialValues,
+        fetchParams: fetchParams,
+        onSearchHandle: onSearchHandle,
+        onResetHandle: onResetHandle,
+    };
+}
+// 模态表格相关逻辑
+var initSelectedRowKeys = [];
+var initSelectedRows = [];
+export function useModalTable(choiceOptions, setData) {
+    var tablePropsChoiceFilterHandle = choiceOptions.tablePropsChoiceFilterHandle, tablePropsSelectedRowKeys = choiceOptions.tablePropsSelectedRowKeys, tablePropsSelectedRows = choiceOptions.tablePropsSelectedRows, tablePropsIsRepeatChoice = choiceOptions.tablePropsIsRepeatChoice, visible = choiceOptions.visible;
+    // 内部管理已选中行
+    var _a = useState(initSelectedRowKeys), innerSelectedRowKeys = _a[0], setInnerSelectedRowKeys = _a[1];
+    var _b = useState(initSelectedRows), innerSelectedRows = _b[0], setInnerSelectedRows = _b[1];
+    // 是否要默认选中，如果设置了默认选中，那么模态框展示的时候 需要默认选中
+    useEffect(function () {
+        if (visible) {
+            if (tablePropsIsRepeatChoice) {
+                setInnerSelectedRowKeys(tablePropsSelectedRowKeys);
+                setInnerSelectedRows(tablePropsSelectedRows);
+            }
+        }
+    }, [
+        visible,
+        tablePropsIsRepeatChoice,
+        tablePropsSelectedRowKeys,
+        tablePropsSelectedRows,
+    ]);
+    // 选中行 触发事件
+    var onSelectedRowChange = useCallback(function (selectedRowKeys, selectedRows) {
+        setInnerSelectedRowKeys(selectedRowKeys);
+        setInnerSelectedRows(selectedRows);
+    }, []);
+    // 过滤规则
+    var choiceFilterHandle = useCallback(function (record, selectedRowKeys, selectedRows) {
+        if (tablePropsChoiceFilterHandle) {
+            return tablePropsChoiceFilterHandle(record, selectedRowKeys, selectedRows);
+        }
+        return {};
+    }, [tablePropsChoiceFilterHandle]);
+    // 表格onChange事件
+    var onTableChange = useCallback(function (newData) {
+        setData(newData);
+    }, [setData]);
+    return {
+        innerSelectedRowKeys: innerSelectedRowKeys,
+        setInnerSelectedRowKeys: setInnerSelectedRowKeys,
+        innerSelectedRows: innerSelectedRows,
+        setInnerSelectedRows: setInnerSelectedRows,
+        onSelectedRowChange: onSelectedRowChange,
+        choiceFilterHandle: choiceFilterHandle,
+        onTableChange: onTableChange,
+    };
+}
+// 底部按钮相关
+export function useFooter(onClose, choiceOptions, data) {
+    var innerSelectedRowKeys = choiceOptions.innerSelectedRowKeys, setInnerSelectedRowKeys = choiceOptions.setInnerSelectedRowKeys, setInnerSelectedRows = choiceOptions.setInnerSelectedRows, tablePropsOnSelectedRowChange = choiceOptions.tablePropsOnSelectedRowChange, tablePropsRowKey = choiceOptions.tablePropsRowKey; // 内部选中项
+    // 点击确认选择 触发回调 清空内部选中项
+    // 重置值为最新值
+    var onSureHandle = useCallback(function () {
+        if (!Array.isArray(innerSelectedRowKeys) ||
+            innerSelectedRowKeys.length === 0) {
+            message.info('请选择数据！');
+            return;
+        }
+        // 找到真实得数据
+        var newInnerSelectedRows = [];
+        if (Array.isArray(data)) {
+            innerSelectedRowKeys.forEach(function (rowKey) {
+                var item = data.find(function (dataItem) { return dataItem[tablePropsRowKey] === rowKey; });
+                if (item) {
+                    newInnerSelectedRows.push(item);
+                }
+            });
+        }
+        tablePropsOnSelectedRowChange &&
+            tablePropsOnSelectedRowChange(innerSelectedRowKeys, newInnerSelectedRows);
+        setInnerSelectedRowKeys(initSelectedRowKeys);
+        setInnerSelectedRows(initSelectedRows);
+        onClose && onClose();
+    }, [
+        innerSelectedRowKeys,
+        setInnerSelectedRowKeys,
+        setInnerSelectedRows,
+        tablePropsOnSelectedRowChange,
+        onClose,
+        data,
+        tablePropsRowKey,
+    ]);
+    var onCloseHandle = useCallback(function () {
+        setInnerSelectedRowKeys(initSelectedRowKeys);
+        setInnerSelectedRows(initSelectedRows);
+        onClose && onClose();
+    }, [onClose, setInnerSelectedRowKeys, setInnerSelectedRows]);
+    var footerDom = useMemo(function () {
+        return [
+            {
+                DOMType: 'button',
+                type: 'default',
+                text: '取消',
+                onClick: onCloseHandle,
+            },
+            {
+                DOMType: 'button',
+                type: 'primary',
+                text: '确认选择',
+                onClick: onSureHandle,
+            },
+        ];
+    }, [onCloseHandle, onSureHandle]);
+    return {
+        footerDom: footerDom,
+        onCloseHandle: onCloseHandle,
+    };
+}

package/dist/components/ProModal/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 模态框封装
+ * 是否需要每次打开模态框都是初始状态
+ * 1. 表单部分
+ * 2. 表格部分
+ * 3. 子表部分
+ */
+import React from 'react';
+import { IProModalProps } from './interface';
+declare function ProModal(props: IProModalProps): JSX.Element;
+export declare function useVisible(): {
+    visible: boolean;
+    onClose: () => void;
+    onOpen: () => void;
+};
+declare const _default: React.MemoExoticComponent<typeof ProModal>;
+export default _default;