amis 2.0.0-rc.9 → 2.0.2

package/esm/renderers/Table/TableBody.js

@@ -0,0 +1,105 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __assign, __decorate } from 'tslib';
+import React from 'react';
+import { TableRow } from './TableRow.js';
+import { filter, createObject } from 'amis-core';
+import { observer } from 'mobx-react';
+
+var TableBody = /** @class */ (function (_super) {
+    __extends(TableBody, _super);
+    function TableBody() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TableBody.prototype.renderRows = function (rows, columns, rowProps) {
+        var _this = this;
+        if (columns === void 0) { columns = this.props.columns; }
+        if (rowProps === void 0) { rowProps = {}; }
+        var _a = this.props, rowClassName = _a.rowClassName, rowClassNameExpr = _a.rowClassNameExpr, onAction = _a.onAction, buildItemProps = _a.buildItemProps, checkOnItemClick = _a.checkOnItemClick, cx = _a.classnames, render = _a.render, renderCell = _a.renderCell, onCheck = _a.onCheck, onQuickChange = _a.onQuickChange, footable = _a.footable, ignoreFootableContent = _a.ignoreFootableContent, footableColumns = _a.footableColumns, itemAction = _a.itemAction;
+        return rows.map(function (item, rowIndex) {
+            var itemProps = buildItemProps ? buildItemProps(item, rowIndex) : null;
+            var doms = [
+                React.createElement(TableRow, __assign({}, itemProps, { itemAction: itemAction, classnames: cx, checkOnItemClick: checkOnItemClick, key: item.id, itemIndex: rowIndex, item: item, itemClassName: cx(rowClassNameExpr
+                        ? filter(rowClassNameExpr, item.data)
+                        : rowClassName, {
+                        'is-last': item.depth > 1 && rowIndex === rows.length - 1
+                    }), columns: columns, renderCell: renderCell, render: render, onAction: onAction, onCheck: onCheck, 
+                    // todo 先注释 quickEditEnabled={item.depth === 1}
+                    onQuickChange: onQuickChange }, rowProps))
+            ];
+            if (footable && footableColumns.length) {
+                if (item.depth === 1) {
+                    doms.push(React.createElement(TableRow, __assign({}, itemProps, { itemAction: itemAction, classnames: cx, checkOnItemClick: checkOnItemClick, key: "foot-".concat(item.id), itemIndex: rowIndex, item: item, itemClassName: cx(rowClassNameExpr
+                            ? filter(rowClassNameExpr, item.data)
+                            : rowClassName), columns: footableColumns, renderCell: renderCell, render: render, onAction: onAction, onCheck: onCheck, footableMode: true, footableColSpan: columns.length, onQuickChange: onQuickChange, ignoreFootableContent: ignoreFootableContent }, rowProps)));
+                }
+            }
+            else if (item.children.length && item.expanded) {
+                // 嵌套表格
+                doms.push.apply(doms, _this.renderRows(item.children, columns, __assign(__assign({}, rowProps), { parent: item })));
+            }
+            return doms;
+        });
+    };
+    TableBody.prototype.renderSummaryRow = function (position, items, rowIndex) {
+        var _a = this.props, columns = _a.columns, render = _a.render, data = _a.data, cx = _a.classnames, rows = _a.rows, prefixRowClassName = _a.prefixRowClassName, affixRowClassName = _a.affixRowClassName;
+        if (!(Array.isArray(items) && items.length)) {
+            return null;
+        }
+        var filterColumns = columns.filter(function (item) { return item.toggable; });
+        var result = [];
+        for (var index = 0; index < filterColumns.length; index++) {
+            var item = items[filterColumns[index].rawIndex];
+            item && result.push(__assign({}, item));
+        }
+        //  如果是勾选栏，让它和下一列合并。
+        if (columns[0].type === '__checkme' && result[0]) {
+            result[0].colSpan = (result[0].colSpan || 1) + 1;
+        }
+        //  如果是展开栏，让它和下一列合并。
+        if (columns[0].type === '__expandme' && result[0]) {
+            result[0].colSpan = (result[0].colSpan || 1) + 1;
+        }
+        // 缺少的单元格补齐
+        var appendLen = columns.length - result.reduce(function (p, c) { return p + (c.colSpan || 1); }, 0);
+        if (appendLen) {
+            var item = result.pop();
+            result.push(__assign(__assign({}, item), { colSpan: (item.colSpan || 1) + appendLen }));
+        }
+        var ctx = createObject(data, {
+            items: rows.map(function (row) { return row.locals; })
+        });
+        return (React.createElement("tr", { className: cx('Table-tr', 'is-summary', position === 'prefix' ? prefixRowClassName : '', position === 'affix' ? affixRowClassName : ''), key: "summary-".concat(position, "-").concat(rowIndex || 0) }, result.map(function (item, index) {
+            var Com = item.isHead ? 'th' : 'td';
+            return (React.createElement(Com, { key: index, colSpan: item.colSpan, className: item.cellClassName }, render("summary-row/".concat(index), item, {
+                data: ctx
+            })));
+        })));
+    };
+    TableBody.prototype.renderSummary = function (position, items) {
+        var _this = this;
+        return Array.isArray(items)
+            ? items.some(function (i) { return Array.isArray(i); })
+                ? items.map(function (i, rowIndex) {
+                    return _this.renderSummaryRow(position, Array.isArray(i) ? i : [i], rowIndex);
+                })
+                : this.renderSummaryRow(position, items)
+            : null;
+    };
+    TableBody.prototype.render = function () {
+        var _a = this.props; _a.classnames; var className = _a.className; _a.render; var rows = _a.rows, columns = _a.columns, rowsProps = _a.rowsProps, prefixRow = _a.prefixRow, affixRow = _a.affixRow; _a.translate;
+        return (React.createElement("tbody", { className: className }, rows.length ? (React.createElement(React.Fragment, null,
+            this.renderSummary('prefix', prefixRow),
+            this.renderRows(rows, columns, rowsProps),
+            this.renderSummary('affix', affixRow))) : null));
+    };
+    TableBody = __decorate([
+        observer
+    ], TableBody);
+    return TableBody;
+}(React.Component));
+
+export { TableBody };

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

@@ -0,0 +1,21 @@
+import React from 'react';
+import { RendererProps } from 'amis-core';
+export interface TableCellProps extends RendererProps {
+    wrapperComponent?: React.ReactType;
+    column: object;
+}
+export declare class TableCell extends React.Component<RendererProps> {
+    static defaultProps: {
+        wrapperComponent: string;
+    };
+    static propsList: Array<string>;
+    render(): JSX.Element;
+}
+export declare class TableCellRenderer extends TableCell {
+    static propsList: string[];
+}
+export declare class FieldRenderer extends TableCell {
+    static defaultProps: {
+        wrapperComponent: string;
+    };
+}

package/esm/renderers/Table/TableCell.js

@@ -0,0 +1,139 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __rest, __assign, __spreadArray, __decorate } from 'tslib';
+import React from 'react';
+import { isPureVariable, resolveVariableAndFilter, ColorScale, filter, Renderer } from 'amis-core';
+import { HocQuickEdit } from '../QuickEdit.js';
+import { HocCopyable } from '../Copyable.js';
+import { HocPopOver } from '../PopOver.js';
+import { observer } from 'mobx-react';
+import omit from 'lodash/omit';
+import { Badge } from 'amis-ui';
+
+var TableCell = /** @class */ (function (_super) {
+    __extends(TableCell, _super);
+    function TableCell() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TableCell.prototype.render = function () {
+        var _a = this.props, cx = _a.classnames, className = _a.className; _a.classNameExpr; var render = _a.render, _b = _a.style, style = _b === void 0 ? {} : _b, Component = _a.wrapperComponent, column = _a.column, value = _a.value, data = _a.data, children = _a.children, width = _a.width, align = _a.align, innerClassName = _a.innerClassName; _a.label; var tabIndex = _a.tabIndex, onKeyUp = _a.onKeyUp, rowSpan = _a.rowSpan; _a.body; _a.tpl; _a.remark; var prefix = _a.prefix, affix = _a.affix, isHead = _a.isHead; _a.colIndex; var row = _a.row, showBadge = _a.showBadge, itemBadge = _a.itemBadge, rest = __rest(_a, ["classnames", "className", "classNameExpr", "render", "style", "wrapperComponent", "column", "value", "data", "children", "width", "align", "innerClassName", "label", "tabIndex", "onKeyUp", "rowSpan", "body", "tpl", "remark", "prefix", "affix", "isHead", "colIndex", "row", "showBadge", "itemBadge"]);
+        var schema = __assign(__assign({}, column), { className: innerClassName, type: (column && column.type) || 'plain' });
+        // 如果本来就是 type 为 button，不要删除，其他情况下都应该删除。
+        if (schema.type !== 'button' && schema.type !== 'dropdown-button') {
+            delete schema.label;
+        }
+        var body = children
+            ? children
+            : render('field', schema, __assign(__assign({}, omit(rest, Object.keys(schema))), { inputOnly: true, value: value, data: data }));
+        if (width) {
+            style = __assign(__assign({}, style), { width: (style && style.width) || width });
+            if (!/%$/.test(String(style.width))) {
+                body = (React.createElement("div", { style: { width: style.width } },
+                    prefix,
+                    body,
+                    affix));
+                prefix = null;
+                affix = null;
+                // delete style.width;
+            }
+        }
+        if (align) {
+            style = __assign(__assign({}, style), { textAlign: align });
+        }
+        if (column.backgroundScale) {
+            var backgroundScale = column.backgroundScale;
+            var min = backgroundScale.min;
+            var max = backgroundScale.max;
+            if (isPureVariable(min)) {
+                min = resolveVariableAndFilter(min, data, '| raw');
+            }
+            if (isPureVariable(max)) {
+                max = resolveVariableAndFilter(max, data, '| raw');
+            }
+            if (typeof min === 'undefined') {
+                min = Math.min.apply(Math, data.rows.map(function (r) { return r[column.name]; }));
+            }
+            if (typeof max === 'undefined') {
+                max = Math.max.apply(Math, data.rows.map(function (r) { return r[column.name]; }));
+            }
+            var colorScale = new ColorScale(min, max, backgroundScale.colors || ['#FFEF9C', '#FF7127']);
+            var value_1 = data[column.name];
+            if (isPureVariable(backgroundScale.source)) {
+                value_1 = resolveVariableAndFilter(backgroundScale.source, data, '| raw');
+            }
+            var color = colorScale.getColor(Number(value_1)).toHexString();
+            style.background = color;
+        }
+        if (!Component) {
+            return body;
+        }
+        if (isHead) {
+            Component = 'th';
+        }
+        return (React.createElement(Component, { rowSpan: rowSpan > 1 ? rowSpan : undefined, style: style, className: cx(className, column.classNameExpr ? filter(column.classNameExpr, data) : null), tabIndex: tabIndex, onKeyUp: onKeyUp },
+            showBadge ? (React.createElement(Badge, { classnames: cx, badge: __assign(__assign({}, itemBadge), { className: cx("Table-badge", itemBadge === null || itemBadge === void 0 ? void 0 : itemBadge.className) }), data: row.data })) : null,
+            prefix,
+            body,
+            affix));
+    };
+    TableCell.defaultProps = {
+        wrapperComponent: 'td'
+    };
+    TableCell.propsList = [
+        'type',
+        'label',
+        'column',
+        'body',
+        'tpl',
+        'rowSpan',
+        'remark'
+    ];
+    return TableCell;
+}(React.Component));
+/** @class */ ((function (_super) {
+    __extends(TableCellRenderer, _super);
+    function TableCellRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TableCellRenderer.propsList = __spreadArray([
+        'quickEdit',
+        'quickEditEnabledOn',
+        'popOver',
+        'copyable',
+        'inline'
+    ], TableCell.propsList, true);
+    TableCellRenderer = __decorate([
+        Renderer({
+            test: /(^|\/)table\/(?:.*\/)?cell$/,
+            name: 'table-cell'
+        }),
+        HocQuickEdit(),
+        HocPopOver({
+            targetOutter: true
+        }),
+        HocCopyable(),
+        observer
+    ], TableCellRenderer);
+    return TableCellRenderer;
+})(TableCell));
+/** @class */ ((function (_super) {
+    __extends(FieldRenderer, _super);
+    function FieldRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    FieldRenderer.defaultProps = __assign(__assign({}, TableCell.defaultProps), { wrapperComponent: 'div' });
+    FieldRenderer = __decorate([
+        Renderer({
+            type: 'field',
+            name: 'field'
+        }),
+        HocPopOver(),
+        HocCopyable()
+    ], FieldRenderer);
+    return FieldRenderer;
+})(TableCell));
+
+export { TableCell };

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

@@ -0,0 +1,54 @@
+import React from 'react';
+import { ClassNamesFn } from 'amis-core';
+import { ITableStore } from 'amis-core';
+import { SchemaNode, ActionObject } from 'amis-core';
+import { LocaleProps } from 'amis-core';
+import { ActionSchema } from '../Action';
+import { SchemaTpl } from '../../Schema';
+import { OnEventProps } from 'amis-core';
+import type { IColumn, IRow } from 'amis-core/lib/store/table';
+export interface TableContentProps extends LocaleProps {
+    className?: string;
+    tableClassName?: string;
+    classnames: ClassNamesFn;
+    columns: Array<IColumn>;
+    columnsGroup: Array<{
+        label: string;
+        index: number;
+        colSpan: number;
+        rowSpan: number;
+        has: Array<any>;
+    }>;
+    rows: Array<IRow>;
+    placeholder?: string | SchemaTpl;
+    render: (region: string, node: SchemaNode, props?: any) => JSX.Element;
+    onMouseMove: (event: React.MouseEvent) => void;
+    onScroll: (event: React.UIEvent) => void;
+    tableRef: (table?: HTMLTableElement | null) => void;
+    renderHeadCell: (column: IColumn, 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;
+    footableColumns: Array<IColumn>;
+    checkOnItemClick?: boolean;
+    buildItemProps?: (item: IRow, index: number) => any;
+    onAction?: (e: React.UIEvent<any>, action: ActionObject, ctx: object) => void;
+    rowClassNameExpr?: string;
+    affixRowClassName?: string;
+    prefixRowClassName?: string;
+    rowClassName?: string;
+    data?: any;
+    prefixRow?: Array<any>;
+    affixRow?: Array<any>;
+    itemAction?: ActionSchema;
+    itemActions?: Array<ActionObject>;
+    store: ITableStore;
+    dispatchEvent?: Function;
+    onEvent?: OnEventProps;
+    loading?: boolean;
+}
+export declare class TableContent extends React.Component<TableContentProps> {
+    renderItemActions(): JSX.Element | null;
+    render(): JSX.Element;
+}

package/esm/renderers/Table/TableContent.js

@@ -0,0 +1,69 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __assign, __decorate } from 'tslib';
+import React from 'react';
+import { TableBody } from './TableBody.js';
+import { observer } from 'mobx-react';
+import ItemActionsWrapper from './ItemActionsWrapper.js';
+import { Icon } from 'amis-ui';
+
+var TableContent = /** @class */ (function (_super) {
+    __extends(TableContent, _super);
+    function TableContent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TableContent.prototype.renderItemActions = function () {
+        var _a = this.props, itemActions = _a.itemActions, render = _a.render, store = _a.store, cx = _a.classnames;
+        var finalActions = Array.isArray(itemActions)
+            ? itemActions.filter(function (action) { return !action.hiddenOnHover; })
+            : [];
+        if (!finalActions.length) {
+            return null;
+        }
+        return (React.createElement(ItemActionsWrapper, { store: store, classnames: cx },
+            React.createElement("div", { className: cx('Table-itemActions') }, finalActions.map(function (action, index) {
+                return render("itemAction/".concat(index), __assign(__assign({}, action), { isMenuItem: true }), {
+                    key: index,
+                    item: store.hoverRow,
+                    data: store.hoverRow.locals,
+                    rowIndex: store.hoverRow.index
+                });
+            }))));
+    };
+    TableContent.prototype.render = function () {
+        var _a = this.props, placeholder = _a.placeholder, cx = _a.classnames, render = _a.render, className = _a.className, columns = _a.columns, columnsGroup = _a.columnsGroup, onMouseMove = _a.onMouseMove, onScroll = _a.onScroll, tableRef = _a.tableRef, rows = _a.rows, renderHeadCell = _a.renderHeadCell, renderCell = _a.renderCell, onCheck = _a.onCheck, rowClassName = _a.rowClassName, onQuickChange = _a.onQuickChange, footable = _a.footable, footableColumns = _a.footableColumns, checkOnItemClick = _a.checkOnItemClick, buildItemProps = _a.buildItemProps, onAction = _a.onAction, rowClassNameExpr = _a.rowClassNameExpr, affixRowClassName = _a.affixRowClassName, prefixRowClassName = _a.prefixRowClassName, data = _a.data, prefixRow = _a.prefixRow, locale = _a.locale, translate = _a.translate, itemAction = _a.itemAction, affixRow = _a.affixRow, store = _a.store, dispatchEvent = _a.dispatchEvent, onEvent = _a.onEvent, loading = _a.loading;
+        var tableClassName = cx('Table-table', this.props.tableClassName);
+        var hideHeader = columns.every(function (column) { return !column.label; });
+        return (React.createElement("div", { onMouseMove: onMouseMove, className: cx('Table-content', className), onScroll: onScroll },
+            store.hoverRow ? this.renderItemActions() : null,
+            React.createElement("table", { ref: tableRef, className: tableClassName },
+                React.createElement("thead", null,
+                    columnsGroup.length ? (React.createElement("tr", null, columnsGroup.map(function (item, index) { return (React.createElement("th", { key: index, "data-index": item.index, colSpan: item.colSpan, rowSpan: item.rowSpan }, item.label ? render('tpl', item.label) : null)); }))) : null,
+                    React.createElement("tr", { className: hideHeader ? 'fake-hide' : '' }, columns.map(function (column) {
+                        var _a;
+                        return ((_a = columnsGroup.find(function (group) { return ~group.has.indexOf(column); })) === null || _a === void 0 ? void 0 : _a.rowSpan) === 2
+                            ? null
+                            : renderHeadCell(column, {
+                                'data-index': column.index,
+                                'key': column.index
+                            });
+                    }))),
+                !rows.length ? (React.createElement("tbody", null,
+                    React.createElement("tr", { className: cx('Table-placeholder') }, !loading ? (React.createElement("td", { colSpan: columns.length }, typeof placeholder === 'string' ? (React.createElement(React.Fragment, null,
+                        React.createElement(Icon, { icon: "desk-empty", className: cx('Table-placeholder-empty-icon', 'icon') }),
+                        translate(placeholder || 'placeholder.noData'))) : (render('placeholder', translate(placeholder || 'placeholder.noData'))))) : null))) : (React.createElement(TableBody, { itemAction: itemAction, classnames: cx, render: render, renderCell: renderCell, onCheck: onCheck, onQuickChange: onQuickChange, footable: footable, footableColumns: footableColumns, checkOnItemClick: checkOnItemClick, buildItemProps: buildItemProps, onAction: onAction, rowClassNameExpr: rowClassNameExpr, rowClassName: rowClassName, prefixRowClassName: prefixRowClassName, affixRowClassName: affixRowClassName, rows: rows, columns: columns, locale: locale, translate: translate, prefixRow: prefixRow, affixRow: affixRow, data: data, rowsProps: {
+                        data: data,
+                        dispatchEvent: dispatchEvent,
+                        onEvent: onEvent
+                    } })))));
+    };
+    TableContent = __decorate([
+        observer
+    ], TableContent);
+    return TableContent;
+}(React.Component));
+
+export { TableContent };

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

@@ -0,0 +1,27 @@
+import React from 'react';
+import type { IColumn, IRow } from 'amis-core/lib/store/table';
+import { RendererProps } from 'amis-core';
+import { Action } from '../Action';
+interface TableRowProps extends Pick<RendererProps, 'render'> {
+    onCheck: (item: IRow) => void;
+    classPrefix: string;
+    renderCell: (region: string, column: IColumn, item: IRow, props: any) => React.ReactNode;
+    columns: Array<IColumn>;
+    item: IRow;
+    parent?: IRow;
+    itemClassName?: string;
+    itemIndex: number;
+    regionPrefix?: string;
+    checkOnItemClick?: boolean;
+    ignoreFootableContent?: boolean;
+    [propName: string]: any;
+}
+export declare class TableRow extends React.Component<TableRowProps> {
+    constructor(props: TableRowProps);
+    handleItemClick(e: React.MouseEvent<HTMLTableRowElement>): Promise<void>;
+    handleAction(e: React.UIEvent<any>, action: Action, ctx: any): void;
+    handleQuickChange(values: object, saveImmediately?: boolean, savePristine?: boolean, resetOnFailed?: boolean): void;
+    handleChange(value: any, name: string, submit?: boolean, changePristine?: boolean): void;
+    render(): JSX.Element | null;
+}
+export {};

package/esm/renderers/Table/TableRow.js

@@ -0,0 +1,129 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __awaiter, __generator, __rest, __assign, __decorate, __metadata } from 'tslib';
+import { observer } from 'mobx-react';
+import React from 'react';
+import { isClickOnInput, createObject } from 'amis-core';
+
+var TableRow = /** @class */ (function (_super) {
+    __extends(TableRow, _super);
+    // reaction?: () => void;
+    function TableRow(props) {
+        var _this = _super.call(this, props) || this;
+        _this.handleAction = _this.handleAction.bind(_this);
+        _this.handleQuickChange = _this.handleQuickChange.bind(_this);
+        _this.handleChange = _this.handleChange.bind(_this);
+        _this.handleItemClick = _this.handleItemClick.bind(_this);
+        return _this;
+    }
+    // 定义点击一行的行为，通过 itemAction配置
+    TableRow.prototype.handleItemClick = function (e) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, itemAction, onAction, item, data, dispatchEvent, rendererEvent;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (isClickOnInput(e)) {
+                            return [2 /*return*/];
+                        }
+                        _a = this.props, itemAction = _a.itemAction, onAction = _a.onAction, item = _a.item, data = _a.data, dispatchEvent = _a.dispatchEvent;
+                        return [4 /*yield*/, dispatchEvent('rowClick', createObject(data, {
+                                rowItem: item === null || item === void 0 ? void 0 : item.data
+                            }))];
+                    case 1:
+                        rendererEvent = _b.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        if (itemAction) {
+                            onAction && onAction(e, itemAction, item === null || item === void 0 ? void 0 : item.data);
+                            item.toggle();
+                        }
+                        else {
+                            this.props.onCheck(this.props.item);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TableRow.prototype.handleAction = function (e, action, ctx) {
+        var _a = this.props, onAction = _a.onAction, item = _a.item;
+        onAction && onAction(e, action, ctx || item.data);
+    };
+    TableRow.prototype.handleQuickChange = function (values, saveImmediately, savePristine, resetOnFailed) {
+        var _a = this.props, onQuickChange = _a.onQuickChange, item = _a.item;
+        onQuickChange &&
+            onQuickChange(item, values, saveImmediately, savePristine, resetOnFailed);
+    };
+    TableRow.prototype.handleChange = function (value, name, submit, changePristine) {
+        var _a;
+        if (!name || typeof name !== 'string') {
+            return;
+        }
+        var _b = this.props, item = _b.item, onQuickChange = _b.onQuickChange;
+        onQuickChange === null || onQuickChange === void 0 ? void 0 : onQuickChange(item, (_a = {},
+            _a[name] = value,
+            _a), submit, changePristine);
+    };
+    TableRow.prototype.render = function () {
+        var _a, _b;
+        var _this = this;
+        var _c = this.props, itemClassName = _c.itemClassName, itemIndex = _c.itemIndex, item = _c.item, columns = _c.columns, renderCell = _c.renderCell; _c.children; var footableMode = _c.footableMode, ignoreFootableContent = _c.ignoreFootableContent, footableColSpan = _c.footableColSpan, regionPrefix = _c.regionPrefix, checkOnItemClick = _c.checkOnItemClick; _c.classPrefix; var render = _c.render, cx = _c.classnames, parent = _c.parent, itemAction = _c.itemAction, onEvent = _c.onEvent, rest = __rest(_c, ["itemClassName", "itemIndex", "item", "columns", "renderCell", "children", "footableMode", "ignoreFootableContent", "footableColSpan", "regionPrefix", "checkOnItemClick", "classPrefix", "render", "classnames", "parent", "itemAction", "onEvent"]);
+        if (footableMode) {
+            if (!item.expanded) {
+                return null;
+            }
+            return (React.createElement("tr", { "data-id": item.id, "data-index": item.newIndex, onClick: checkOnItemClick || itemAction || (onEvent === null || onEvent === void 0 ? void 0 : onEvent.rowClick)
+                    ? this.handleItemClick
+                    : undefined, className: cx(itemClassName, (_a = {
+                        'is-hovered': item.isHover,
+                        'is-checked': item.checked,
+                        'is-modified': item.modified,
+                        'is-moved': item.moved
+                    },
+                    _a["Table-tr--hasItemAction"] = itemAction,
+                    _a["Table-tr--odd"] = itemIndex % 2 === 0,
+                    _a["Table-tr--even"] = itemIndex % 2 === 1,
+                    _a)) },
+                React.createElement("td", { className: cx("Table-foot"), colSpan: footableColSpan },
+                    React.createElement("table", { className: cx("Table-footTable") },
+                        React.createElement("tbody", null, ignoreFootableContent
+                            ? columns.map(function (column) { return (React.createElement("tr", { key: column.index },
+                                column.label !== false ? React.createElement("th", null) : null,
+                                React.createElement("td", null))); })
+                            : columns.map(function (column) { return (React.createElement("tr", { key: column.index },
+                                column.label !== false ? (React.createElement("th", null, render("".concat(regionPrefix).concat(itemIndex, "/").concat(column.index, "/tpl"), column.label))) : null,
+                                renderCell("".concat(regionPrefix).concat(itemIndex, "/").concat(column.index), column, item, __assign(__assign({}, rest), { width: null, rowIndex: itemIndex, colIndex: column.index, key: column.index, onAction: _this.handleAction, onQuickChange: _this.handleQuickChange, onChange: _this.handleChange })))); }))))));
+        }
+        if (parent && !parent.expanded) {
+            return null;
+        }
+        return (React.createElement("tr", { onClick: checkOnItemClick || itemAction || (onEvent === null || onEvent === void 0 ? void 0 : onEvent.rowClick)
+                ? this.handleItemClick
+                : undefined, "data-index": item.depth === 1 ? item.newIndex : undefined, "data-id": item.id, className: cx(itemClassName, (_b = {
+                    'is-hovered': item.isHover,
+                    'is-checked': item.checked,
+                    'is-modified': item.modified,
+                    'is-moved': item.moved,
+                    'is-expanded': item.expanded && item.expandable,
+                    'is-expandable': item.expandable
+                },
+                _b["Table-tr--hasItemAction"] = itemAction,
+                _b["Table-tr--odd"] = itemIndex % 2 === 0,
+                _b["Table-tr--even"] = itemIndex % 2 === 1,
+                _b), "Table-tr--".concat(item.depth, "th")) }, columns.map(function (column) {
+            return renderCell("".concat(itemIndex, "/").concat(column.index), column, item, __assign(__assign({}, rest), { rowIndex: itemIndex, colIndex: column.index, key: column.index, onAction: _this.handleAction, onQuickChange: _this.handleQuickChange, onChange: _this.handleChange }));
+        })));
+    };
+    TableRow = __decorate([
+        observer,
+        __metadata("design:paramtypes", [Object])
+    ], TableRow);
+    return TableRow;
+}(React.Component));
+
+export { TableRow };

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

@@ -0,0 +1,6 @@
+/**
+ * 导出 Excel 功能
+ */
+import './ColumnToggler';
+import type { TableProps, ExportExcelToolbar } from './index';
+export declare function exportExcel(ExcelJS: any, props: TableProps, toolbar: ExportExcelToolbar): Promise<void>;