amis 2.0.0-rc.9 → 2.0.2

package/esm/renderers/Table/HeadCellFilterDropdown.js

@@ -0,0 +1,211 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __assign, __awaiter, __generator } from 'tslib';
+import React from 'react';
+import { isApiOutdated, getVariable, isEffectiveApi, normalizeApi, normalizeOptions, createObject, Overlay, PopOver } from 'amis-core';
+import { Icon, Checkbox } from 'amis-ui';
+import { findDOMNode } from 'react-dom';
+import xor from 'lodash/xor';
+
+var HeadCellFilterDropDown = /** @class */ (function (_super) {
+    __extends(HeadCellFilterDropDown, _super);
+    function HeadCellFilterDropDown(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            isOpened: false,
+            filterOptions: []
+        };
+        _this.sourceInvalid = false;
+        _this.open = _this.open.bind(_this);
+        _this.close = _this.close.bind(_this);
+        _this.handleClick = _this.handleClick.bind(_this);
+        _this.handleCheck = _this.handleCheck.bind(_this);
+        return _this;
+    }
+    HeadCellFilterDropDown.prototype.componentDidMount = function () {
+        var _a;
+        var _b = this.props, filterable = _b.filterable; _b.name; _b.store;
+        if (filterable.source) {
+            this.fetchOptions();
+        }
+        else if (((_a = filterable.options) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            this.setState({
+                filterOptions: this.alterOptions(filterable.options)
+            });
+        }
+    };
+    HeadCellFilterDropDown.prototype.componentDidUpdate = function (prevProps, prevState) {
+        var _a, _b, _c, _d;
+        var name = this.props.name;
+        var props = this.props;
+        if (prevProps.name !== props.name ||
+            prevProps.filterable !== props.filterable ||
+            prevProps.data !== props.data) {
+            if (props.filterable.source) {
+                this.sourceInvalid = isApiOutdated(prevProps.filterable.source, props.filterable.source, prevProps.data, props.data);
+            }
+            else if (props.filterable.options) {
+                this.setState({
+                    filterOptions: this.alterOptions(props.filterable.options || [])
+                });
+            }
+            else if (name &&
+                !this.state.filterOptions.length &&
+                (Array.isArray((_a = props.store) === null || _a === void 0 ? void 0 : _a.data.itemsRaw) ||
+                    Array.isArray((_b = props.store) === null || _b === void 0 ? void 0 : _b.data.items))) {
+                var itemsRaw = ((_c = props.store) === null || _c === void 0 ? void 0 : _c.data.itemsRaw) || ((_d = props.store) === null || _d === void 0 ? void 0 : _d.data.items);
+                var values_1 = [];
+                itemsRaw.forEach(function (item) {
+                    var value = getVariable(item, name);
+                    if (!~values_1.indexOf(value)) {
+                        values_1.push(value);
+                    }
+                });
+                if (values_1.length) {
+                    this.setState({
+                        filterOptions: this.alterOptions(values_1)
+                    });
+                }
+            }
+        }
+        var value = this.props.data ? this.props.data[name] : undefined;
+        var prevValue = prevProps.data ? prevProps.data[name] : undefined;
+        if (value !== prevValue &&
+            this.state.filterOptions.length &&
+            prevState.filterOptions !== this.props.filterOptions) {
+            this.setState({
+                filterOptions: this.alterOptions(this.state.filterOptions)
+            });
+        }
+        this.sourceInvalid && this.fetchOptions();
+    };
+    HeadCellFilterDropDown.prototype.fetchOptions = function () {
+        var _this = this;
+        var _a = this.props, env = _a.env, filterable = _a.filterable, data = _a.data;
+        if (!isEffectiveApi(filterable.source, data)) {
+            return;
+        }
+        var api = normalizeApi(filterable.source);
+        api.cache = 3000; // 开启 3s 缓存，因为固顶位置渲染1次会额外多次请求。
+        env.fetcher(api, data).then(function (ret) {
+            var options = (ret.data && ret.data.options) || [];
+            _this.setState({
+                filterOptions: ret && ret.data && _this.alterOptions(options)
+            });
+        });
+    };
+    HeadCellFilterDropDown.prototype.alterOptions = function (options) {
+        var _a = this.props, data = _a.data, filterable = _a.filterable, name = _a.name;
+        var filterValue = data && typeof data[name] !== 'undefined' ? data[name] : '';
+        options = normalizeOptions(options);
+        if (filterable.multiple) {
+            options = options.map(function (option) { return (__assign(__assign({}, option), { selected: filterValue.split(',').indexOf(option.value) > -1 })); });
+        }
+        else {
+            options = options.map(function (option) { return (__assign(__assign({}, option), { selected: option.value == filterValue })); });
+        }
+        return options;
+    };
+    HeadCellFilterDropDown.prototype.handleClickOutside = function () {
+        this.close();
+    };
+    HeadCellFilterDropDown.prototype.open = function () {
+        this.setState({
+            isOpened: true
+        });
+    };
+    HeadCellFilterDropDown.prototype.close = function () {
+        this.setState({
+            isOpened: false
+        });
+    };
+    HeadCellFilterDropDown.prototype.handleClick = function (value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, onQuery, name, data, dispatchEvent, rendererEvent;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = this.props, onQuery = _a.onQuery, name = _a.name, data = _a.data, dispatchEvent = _a.dispatchEvent;
+                        return [4 /*yield*/, dispatchEvent('columnFilter', createObject(data, {
+                                filterName: name,
+                                filterValue: value
+                            }))];
+                    case 1:
+                        rendererEvent = _c.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        onQuery((_b = {},
+                            _b[name] = value,
+                            _b));
+                        this.close();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    HeadCellFilterDropDown.prototype.handleCheck = function (value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, data, name, onQuery, dispatchEvent, query, rendererEvent;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = this.props, data = _a.data, name = _a.name, onQuery = _a.onQuery, dispatchEvent = _a.dispatchEvent;
+                        if (data[name] && data[name] === value) {
+                            query = '';
+                        }
+                        else {
+                            query =
+                                (data[name] && xor(data[name].split(','), [value]).join(',')) || value;
+                        }
+                        return [4 /*yield*/, dispatchEvent('columnFilter', createObject(data, {
+                                filterName: name,
+                                filterValue: query
+                            }))];
+                    case 1:
+                        rendererEvent = _c.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        onQuery((_b = {},
+                            _b[name] = query,
+                            _b));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    HeadCellFilterDropDown.prototype.handleReset = function () {
+        var _a;
+        var _b = this.props, name = _b.name, onQuery = _b.onQuery;
+        onQuery((_a = {},
+            _a[name] = undefined,
+            _a));
+        this.close();
+    };
+    HeadCellFilterDropDown.prototype.render = function () {
+        var _this = this;
+        var _a = this.state, isOpened = _a.isOpened, filterOptions = _a.filterOptions;
+        var _b = this.props, data = _b.data, name = _b.name, filterable = _b.filterable, popOverContainer = _b.popOverContainer, ns = _b.classPrefix, cx = _b.classnames, __ = _b.translate;
+        return (React.createElement("span", { className: cx("".concat(ns, "TableCell-filterBtn"), data && typeof data[name] !== 'undefined' ? 'is-active' : '') },
+            React.createElement("span", { onClick: this.open },
+                React.createElement(Icon, { icon: "column-filter", className: "icon" })),
+            isOpened ? (React.createElement(Overlay, { container: popOverContainer || (function () { return findDOMNode(_this); }), placement: "left-bottom-left-top right-bottom-right-top", target: popOverContainer ? function () { return findDOMNode(_this).parentNode; } : null, show: true },
+                React.createElement(PopOver, { classPrefix: ns, onHide: this.close, className: cx("".concat(ns, "TableCell-filterPopOver"), filterable.className), overlay: true }, filterOptions && filterOptions.length > 0 ? (React.createElement("ul", { className: cx('DropDown-menu') },
+                    !filterable.multiple
+                        ? filterOptions.map(function (option, index) { return (React.createElement("li", { key: index, className: cx({
+                                'is-active': option.selected
+                            }), onClick: _this.handleClick.bind(_this, option.value) }, option.label)); })
+                        : filterOptions.map(function (option, index) { return (React.createElement("li", { key: index },
+                            React.createElement(Checkbox, { classPrefix: ns, onChange: _this.handleCheck.bind(_this, option.value), checked: option.selected }, option.label))); }),
+                    filterOptions.some(function (item) { return item.selected; }) ? (React.createElement("li", { key: "DropDown-menu-reset", onClick: this.handleReset.bind(this) }, __('reset'))) : null)) : null))) : null));
+    };
+    return HeadCellFilterDropDown;
+}(React.Component));
+
+export { HeadCellFilterDropDown };

package/esm/renderers/Table/HeadCellSearchDropdown.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import { RendererProps } from 'amis-core';
+import { ActionObject } from 'amis-core';
+export interface QuickSearchConfig {
+    type?: string;
+    controls?: any;
+    tabs?: any;
+    fieldSet?: any;
+    [propName: string]: any;
+}
+export interface HeadCellSearchProps extends RendererProps {
+    name: string;
+    searchable: boolean | QuickSearchConfig;
+    classPrefix: string;
+    onQuery: (values: object) => void;
+}
+export declare class HeadCellSearchDropDown extends React.Component<HeadCellSearchProps, any> {
+    state: {
+        isOpened: boolean;
+    };
+    formItems: Array<string>;
+    constructor(props: HeadCellSearchProps);
+    buildSchema(): any;
+    handleClickOutside(): void;
+    open(): void;
+    close(): void;
+    handleAction(e: any, action: ActionObject, ctx: object): void;
+    handleReset(): void;
+    handleSubmit(values: any): Promise<void>;
+    isActive(): boolean;
+    render(): JSX.Element;
+}

package/esm/renderers/Table/HeadCellSearchDropdown.js

@@ -0,0 +1,193 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __assign, __awaiter, __generator } from 'tslib';
+import React from 'react';
+import { Icon } from 'amis-ui';
+import { setVariable, createObject, Overlay, PopOver } from 'amis-core';
+import { findDOMNode } from 'react-dom';
+
+var HeadCellSearchDropDown = /** @class */ (function (_super) {
+    __extends(HeadCellSearchDropDown, _super);
+    function HeadCellSearchDropDown(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            isOpened: false
+        };
+        _this.formItems = [];
+        _this.open = _this.open.bind(_this);
+        _this.close = _this.close.bind(_this);
+        _this.handleSubmit = _this.handleSubmit.bind(_this);
+        _this.handleAction = _this.handleAction.bind(_this);
+        return _this;
+    }
+    HeadCellSearchDropDown.prototype.buildSchema = function () {
+        var _a;
+        var _b = this.props, searchable = _b.searchable, sortable = _b.sortable, name = _b.name, label = _b.label, __ = _b.translate;
+        var schema;
+        if (searchable === true) {
+            schema = {
+                title: '',
+                controls: [
+                    {
+                        type: 'text',
+                        name: name,
+                        placeholder: label,
+                        clearable: true
+                    }
+                ]
+            };
+        }
+        else if (searchable) {
+            if (searchable.controls || searchable.tabs || searchable.fieldSet) {
+                schema = __assign(__assign({ title: '' }, searchable), { controls: Array.isArray(searchable.controls)
+                        ? searchable.controls.concat()
+                        : undefined });
+            }
+            else {
+                schema = {
+                    title: '',
+                    className: searchable.formClassName,
+                    controls: [
+                        __assign({ type: searchable.type || 'text', name: searchable.name || name, placeholder: label }, searchable)
+                    ]
+                };
+            }
+        }
+        if (schema && schema.controls && sortable) {
+            schema.controls.unshift({
+                type: 'hidden',
+                name: 'orderBy',
+                value: name
+            }, {
+                type: 'button-group',
+                name: 'orderDir',
+                label: __('sort'),
+                options: [
+                    {
+                        label: __('asc'),
+                        value: 'asc'
+                    },
+                    {
+                        label: __('desc'),
+                        value: 'desc'
+                    }
+                ]
+            });
+        }
+        if (schema) {
+            var formItems_1 = [];
+            (_a = schema.controls) === null || _a === void 0 ? void 0 : _a.forEach(function (item) {
+                return item.name &&
+                    item.name !== 'orderBy' &&
+                    item.name !== 'orderDir' &&
+                    formItems_1.push(item.name);
+            });
+            this.formItems = formItems_1;
+            schema = __assign(__assign({}, schema), { type: 'form', wrapperComponent: 'div', actions: [
+                    {
+                        type: 'button',
+                        label: __('reset'),
+                        actionType: 'clear-and-submit'
+                    },
+                    {
+                        type: 'button',
+                        label: __('cancel'),
+                        actionType: 'cancel'
+                    },
+                    {
+                        label: __('search'),
+                        type: 'submit',
+                        primary: true
+                    }
+                ] });
+        }
+        return schema || 'error';
+    };
+    HeadCellSearchDropDown.prototype.handleClickOutside = function () {
+        this.close();
+    };
+    HeadCellSearchDropDown.prototype.open = function () {
+        this.setState({
+            isOpened: true
+        });
+    };
+    HeadCellSearchDropDown.prototype.close = function () {
+        this.setState({
+            isOpened: false
+        });
+    };
+    HeadCellSearchDropDown.prototype.handleAction = function (e, action, ctx) {
+        var onAction = this.props.onAction;
+        if (action.actionType === 'cancel' || action.actionType === 'close') {
+            this.close();
+            return;
+        }
+        if (action.actionType === 'reset') {
+            this.close();
+            this.handleReset();
+            return;
+        }
+        onAction && onAction(e, action, ctx);
+    };
+    HeadCellSearchDropDown.prototype.handleReset = function () {
+        var _a = this.props, onQuery = _a.onQuery, data = _a.data, name = _a.name;
+        var values = __assign({}, data);
+        this.formItems.forEach(function (key) { return setVariable(values, key, undefined); });
+        if (values.orderBy === name) {
+            values.orderBy = '';
+            values.orderDir = 'asc';
+        }
+        onQuery(values);
+    };
+    HeadCellSearchDropDown.prototype.handleSubmit = function (values) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, onQuery, name, data, dispatchEvent, rendererEvent;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, onQuery = _a.onQuery, name = _a.name, data = _a.data, dispatchEvent = _a.dispatchEvent;
+                        if (values.orderDir) {
+                            values = __assign(__assign({}, values), { orderBy: name });
+                        }
+                        return [4 /*yield*/, dispatchEvent('columnSearch', createObject(data, {
+                                searchName: name,
+                                searchValue: values
+                            }))];
+                    case 1:
+                        rendererEvent = _b.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        this.close();
+                        onQuery(values);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    HeadCellSearchDropDown.prototype.isActive = function () {
+        var _a = this.props, data = _a.data, name = _a.name, orderBy = _a.orderBy;
+        return orderBy === name || this.formItems.some(function (key) { return data === null || data === void 0 ? void 0 : data[key]; });
+    };
+    HeadCellSearchDropDown.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, render = _a.render, name = _a.name, data = _a.data, searchable = _a.searchable, store = _a.store, orderBy = _a.orderBy, popOverContainer = _a.popOverContainer, ns = _a.classPrefix, cx = _a.classnames;
+        var formSchema = this.buildSchema();
+        var isActive = this.isActive();
+        return (React.createElement("span", { className: cx("".concat(ns, "TableCell-searchBtn"), isActive ? 'is-active' : '') },
+            React.createElement("span", { onClick: this.open },
+                React.createElement(Icon, { icon: "search", className: "icon" })),
+            this.state.isOpened ? (React.createElement(Overlay, { container: popOverContainer || (function () { return findDOMNode(_this); }), placement: "left-bottom-left-top right-bottom-right-top", target: popOverContainer ? function () { return findDOMNode(_this).parentNode; } : null, show: true },
+                React.createElement(PopOver, { classPrefix: ns, onHide: this.close, className: cx("".concat(ns, "TableCell-searchPopOver"), searchable.className), overlay: true }, render('quick-search-form', formSchema, {
+                    data: __assign(__assign({}, data), { orderBy: orderBy, orderDir: orderBy === name ? store.orderDir : '' }),
+                    onSubmit: this.handleSubmit,
+                    onAction: this.handleAction
+                })))) : null));
+    };
+    return HeadCellSearchDropDown;
+}(React.Component));
+
+export { HeadCellSearchDropDown };

package/esm/renderers/Table/ItemActionsWrapper.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { ITableStore } from 'amis-core';
+import { ClassNamesFn } from 'amis-core';
+export interface ItemActionsProps {
+    classnames: ClassNamesFn;
+    children: JSX.Element;
+    store: ITableStore;
+}
+declare function ItemActionsWrapper(props: ItemActionsProps): JSX.Element;
+declare const _default: typeof ItemActionsWrapper;
+export default _default;

package/esm/renderers/Table/ItemActionsWrapper.js

@@ -0,0 +1,35 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { observer } from 'mobx-react';
+import React, { useRef, useEffect } from 'react';
+
+function ItemActionsWrapper(props) {
+    var _a;
+    var cx = props.classnames;
+    var children = props.children;
+    var store = props.store;
+    var divRef = useRef(null);
+    useEffect(function () {
+        var _a;
+        var row = store.hoverRow;
+        if (!row) {
+            return;
+        }
+        var frame = (_a = divRef.current.parentElement) === null || _a === void 0 ? void 0 : _a.querySelector('table');
+        var dom = frame === null || frame === void 0 ? void 0 : frame.querySelector("tr[data-id=\"".concat(row.id, "\"]"));
+        if (!dom) {
+            return;
+        }
+        var rect = dom.getBoundingClientRect();
+        var height = rect.height;
+        var top = rect.top - frame.getBoundingClientRect().top;
+        divRef.current.style.cssText += "top: ".concat(top, "px;height: ").concat(height, "px;");
+    }, [(_a = store.hoverRow) === null || _a === void 0 ? void 0 : _a.id]);
+    return (React.createElement("div", { className: cx('Table-itemActions-wrap'), ref: divRef }, children));
+}
+var ItemActionsWrapper$1 = observer(ItemActionsWrapper);
+
+export { ItemActionsWrapper$1 as default };

package/esm/renderers/Table/TableBody.d.ts

@@ -0,0 +1,90 @@
+import React from 'react';
+import { ClassNamesFn } from 'amis-core';
+import { SchemaNode, ActionObject } from 'amis-core';
+import { LocaleProps } from 'amis-core';
+import { ActionSchema } from '../Action';
+import type { IColumn, IRow } from 'amis-core/lib/store/table';
+export interface TableBodyProps extends LocaleProps {
+    className?: string;
+    rowsProps?: any;
+    tableClassName?: string;
+    classnames: ClassNamesFn;
+    columns: Array<IColumn>;
+    rows: Array<IRow>;
+    render: (region: string, node: SchemaNode, props?: any) => JSX.Element;
+    renderCell: (region: string, column: IColumn, item: IRow, props: any) => React.ReactNode;
+    onCheck: (item: IRow, value: boolean, shift?: boolean) => void;
+    onQuickChange?: (item: IRow, values: object, saveImmediately?: boolean | any, savePristine?: boolean) => void;
+    footable?: boolean;
+    ignoreFootableContent?: boolean;
+    footableColumns: Array<IColumn>;
+    checkOnItemClick?: boolean;
+    buildItemProps?: (item: IRow, index: number) => any;
+    onAction?: (e: React.UIEvent<any>, action: ActionObject, ctx: object) => void;
+    rowClassNameExpr?: string;
+    rowClassName?: string;
+    affixRowClassName?: string;
+    prefixRowClassName?: string;
+    data?: any;
+    prefixRow?: Array<any>;
+    affixRow?: Array<any>;
+    itemAction?: ActionSchema;
+}
+export declare class TableBody extends React.Component<TableBodyProps> {
+    renderRows(rows: Array<any>, columns?: ({
+        label: any;
+        type: string;
+        name: string | undefined;
+        value: any;
+        groupName: string;
+        toggled: boolean;
+        toggable: boolean;
+        expandable: boolean;
+        checkdisable: boolean;
+        isPrimary: boolean;
+        searchable: any;
+        enableSearch: boolean;
+        sortable: boolean;
+        filterable: any;
+        fixed: string;
+        index: number;
+        rawIndex: number;
+        breakpoint: any;
+        pristine: any;
+        remark: any;
+        className: any;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        toggleToggle(): void;
+        setToggled(value: boolean): void;
+        setEnableSearch(value: boolean): void;
+    } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+        label: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IType<any, any, any>, [undefined]>;
+        type: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+        name: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+        value: import("mobx-state-tree").IType<any, any, any>;
+        groupName: import("mobx-state-tree").IType<string | undefined, string, string>;
+        toggled: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+        toggable: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+        expandable: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+        checkdisable: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+        isPrimary: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+        searchable: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IType<any, any, any>>;
+        enableSearch: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+        sortable: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+        filterable: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IType<any, any, any>, [undefined]>;
+        fixed: import("mobx-state-tree").IType<string | undefined, string, string>;
+        index: import("mobx-state-tree").IType<number | undefined, number, number>;
+        rawIndex: import("mobx-state-tree").IType<number | undefined, number, number>;
+        breakpoint: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IType<any, any, any>, [undefined]>;
+        pristine: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IType<any, any, any>, [undefined]>;
+        remark: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IType<any, any, any>, [undefined]>;
+        className: import("mobx-state-tree").ITypeUnion<any, any, any>;
+    }, {
+        toggleToggle(): void;
+        setToggled(value: boolean): void;
+        setEnableSearch(value: boolean): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>)[], rowProps?: any): any;
+    renderSummaryRow(position: 'prefix' | 'affix', items?: Array<any>, rowIndex?: number): JSX.Element | null;
+    renderSummary(position: 'prefix' | 'affix', items?: Array<any>): JSX.Element | (JSX.Element | null)[] | null;
+    render(): JSX.Element;
+}