amis-ui 6.13.0-beta.8 → 6.13.0

package/esm/components/InputTable.d.ts

@@ -0,0 +1,317 @@
+/// <reference types="hoist-non-react-statics" />
+import { ClassNamesFn, LocaleProps, ThemeProps, TranslateFn } from 'amis-core';
+import React from 'react';
+import { Control, UseFieldArrayProps, UseFormReturn } from 'react-hook-form';
+import { FormFieldProps } from './FormField';
+import type { ButtonProps } from './Button';
+export interface tdRenderFunc {
+    (methods: UseFormReturn & {
+        popOverContainer?: any;
+    }, colIndex: number, rowIndex: number): JSX.Element | null;
+}
+export interface InputTableColumnProps {
+    title?: string;
+    className?: string;
+    thRender?: () => JSX.Element;
+    tdRender: tdRenderFunc;
+}
+interface InputTableScrollProps {
+    /** 垂直滚动区域的最大高度 */
+    y: number | string;
+}
+export interface InputTabbleProps<T = any> extends ThemeProps, LocaleProps, Omit<FormFieldProps, 'children' | 'errors' | 'hasError' | 'className'>, UseFieldArrayProps {
+    control: Control<any>;
+    fieldClassName?: string;
+    columns: Array<InputTableColumnProps>;
+    /**
+     * 要不要包裹 label 之类的
+     */
+    wrap?: boolean;
+    scaffold?: any;
+    addable?: boolean;
+    addButtonClassName?: string;
+    addButtonText?: string;
+    addButtonProps?: Partial<Omit<ButtonProps, 'onClick'>>;
+    maxLength?: number;
+    minLength?: number;
+    removable?: boolean;
+    /** 表格CSS类名 */
+    tableClassName?: string;
+    /** 表格头CSS类名 */
+    tableHeadClassName?: string;
+    /** 表格内容区CSS类名 */
+    tableBodyClassName?: string;
+    /** 空状态文字 */
+    placeholder?: React.ReactNode;
+    /** 滚动设置 */
+    scroll?: InputTableScrollProps;
+    /** 底部工具栏 */
+    footer?: () => React.ReactNode;
+    onItemAdd?: (values: Record<string, any>) => void;
+}
+export declare function InputTable({ control, name, wrap, mode, label, labelAlign, labelClassName, description, fieldClassName, className, translate: __, classnames: cx, removable, columns, addable, addButtonText, addButtonClassName, addButtonProps, scaffold, minLength, maxLength, isRequired, rules, tableClassName, tableHeadClassName, tableBodyClassName, placeholder, scroll, footer, onItemAdd }: InputTabbleProps): React.JSX.Element;
+export interface InputTableRowProps {
+    value: any;
+    control: Control<any>;
+    columns: Array<{
+        tdRender: tdRenderFunc;
+        className?: string;
+    }>;
+    update: (index: number, data: Record<string, any>) => void;
+    index: number;
+    translate: TranslateFn;
+    classnames: ClassNamesFn;
+    formRef: (form: UseFormReturn | null, id: string) => void;
+    popOverContainer?: any;
+}
+export declare const InputTableRow: React.NamedExoticComponent<InputTableRowProps>;
+declare const _default: {
+    new (props: Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+        locale?: string | undefined;
+        translate?: ((str: string, ...args: any[]) => string) | undefined;
+    }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps): {
+        ref: any;
+        childRef(ref: any): void;
+        getWrappedInstance(): any;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<{
+        new (props: Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }): {
+            ref: any;
+            childRef(ref: any): void;
+            getWrappedInstance(): any;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined; /** 滚动设置 */
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>) => {} | Pick<{}, K_1> | null) | Pick<{}, K_1> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>;
+            state: Readonly<{}>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            componentDidMount?(): void;
+            shouldComponentUpdate?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        displayName: string;
+        contextType: React.Context<string>;
+        ComposedComponent: React.ComponentType<typeof InputTable>;
+    } & import("hoist-non-react-statics").NonReactStatics<typeof InputTable, {}> & {
+        ComposedComponent: typeof InputTable;
+    }>;
+} & import("hoist-non-react-statics").NonReactStatics<{
+    new (props: Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+        locale?: string | undefined;
+        translate?: ((str: string, ...args: any[]) => string) | undefined;
+    }): {
+        ref: any;
+        childRef(ref: any): void;
+        getWrappedInstance(): any;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined; /** 滚动设置 */
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>) => {} | Pick<{}, K_1> | null) | Pick<{}, K_1> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<typeof InputTable>;
+} & import("hoist-non-react-statics").NonReactStatics<typeof InputTable, {}> & {
+    ComposedComponent: typeof InputTable;
+}, {}> & {
+    ComposedComponent: {
+        new (props: Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }): {
+            ref: any;
+            childRef(ref: any): void;
+            getWrappedInstance(): any;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined; /** 滚动设置 */
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>) => {} | Pick<{}, K_1> | null) | Pick<{}, K_1> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>;
+            state: Readonly<{}>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            componentDidMount?(): void;
+            shouldComponentUpdate?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<InputTabbleProps<any>, keyof LocaleProps> & {
+                locale?: string | undefined;
+                translate?: ((str: string, ...args: any[]) => string) | undefined;
+            }>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        displayName: string;
+        contextType: React.Context<string>;
+        ComposedComponent: React.ComponentType<typeof InputTable>;
+    } & import("hoist-non-react-statics").NonReactStatics<typeof InputTable, {}> & {
+        ComposedComponent: typeof InputTable;
+    };
+};
+export default _default;

package/esm/components/InputTable.js

@@ -0,0 +1,176 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __assign, __awaiter, __generator, __values } from 'tslib';
+import { themeable, localeable } from 'amis-core';
+import React__default from 'react';
+import { useFieldArray, useFormState, useFormContext } from 'react-hook-form';
+import useSubForm from '../hooks/use-sub-form.js';
+import Button from './Button.js';
+import ThemedFormField from './FormField.js';
+import { Icon } from './icons.js';
+
+function InputTable(_a) {
+    var _this = this;
+    var _b, _c;
+    var control = _a.control, name = _a.name, wrap = _a.wrap, mode = _a.mode, label = _a.label, labelAlign = _a.labelAlign, labelClassName = _a.labelClassName, description = _a.description, fieldClassName = _a.fieldClassName, className = _a.className, __ = _a.translate, cx = _a.classnames, removable = _a.removable, columns = _a.columns, addable = _a.addable, addButtonText = _a.addButtonText, addButtonClassName = _a.addButtonClassName, addButtonProps = _a.addButtonProps, scaffold = _a.scaffold, minLength = _a.minLength, maxLength = _a.maxLength, isRequired = _a.isRequired, rules = _a.rules, tableClassName = _a.tableClassName, tableHeadClassName = _a.tableHeadClassName, tableBodyClassName = _a.tableBodyClassName, placeholder = _a.placeholder, scroll = _a.scroll, footer = _a.footer, onItemAdd = _a.onItemAdd;
+    var enableScroll = (scroll === null || scroll === void 0 ? void 0 : scroll.y) != null;
+    var tBodyRef = React__default.useRef(null);
+    var tableRef = React__default.useRef(null);
+    var subForms = React__default.useRef({});
+    var subFormRef = React__default.useCallback(function (subform, id) {
+        if (subform) {
+            subForms.current[id] = subform;
+        }
+        else {
+            delete subForms.current[id];
+        }
+    }, [subForms]);
+    var popOverContainer = React__default.useCallback(function () {
+        return tBodyRef.current;
+    }, [tBodyRef]);
+    var finalRules = __assign({}, rules);
+    if (isRequired) {
+        finalRules.required = true;
+    }
+    if (minLength) {
+        finalRules.minLength = minLength;
+    }
+    if (maxLength) {
+        finalRules.maxLength = maxLength;
+    }
+    finalRules.validate = React__default.useCallback(function (items) { return __awaiter(_this, void 0, void 0, function () {
+        var map, result, _a, _b, key, valid, e_1_1;
+        var e_1, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    map = subForms.current;
+                    if (!(typeof (rules === null || rules === void 0 ? void 0 : rules.validate) === 'function')) return [3 /*break*/, 2];
+                    return [4 /*yield*/, rules.validate(items)];
+                case 1:
+                    result = _d.sent();
+                    if (result) {
+                        return [2 /*return*/, result];
+                    }
+                    _d.label = 2;
+                case 2:
+                    _d.trys.push([2, 7, 8, 9]);
+                    _a = __values(Object.keys(map)), _b = _a.next();
+                    _d.label = 3;
+                case 3:
+                    if (!!_b.done) return [3 /*break*/, 6];
+                    key = _b.value;
+                    return [4 /*yield*/, (function (methods) {
+                            return new Promise(function (resolve) {
+                                methods.handleSubmit(function () { return resolve(true); }, function () { return resolve(false); })();
+                            });
+                        })(map[key])];
+                case 4:
+                    valid = _d.sent();
+                    if (!valid) {
+                        return [2 /*return*/, __('validateFailed')];
+                    }
+                    _d.label = 5;
+                case 5:
+                    _b = _a.next();
+                    return [3 /*break*/, 3];
+                case 6: return [3 /*break*/, 9];
+                case 7:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 9];
+                case 8:
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 9: return [2 /*return*/];
+            }
+        });
+    }); }, [subForms]);
+    var _d = useFieldArray({
+        control: control,
+        name: name,
+        rules: finalRules
+    }), fields = _d.fields, append = _d.append; _d.update; var remove = _d.remove;
+    if (!Array.isArray(columns)) {
+        columns = [];
+    }
+    var errors = useFormState({
+        control: control
+    }).errors;
+    var _e = useFormContext(); _e.trigger; var setValue = _e.setValue;
+    // useFieldArray 的 update 会更新行 id，导致重新渲染
+    // 正在编辑中的元素失去焦点，所以自己写一个
+    var lightUpdate = React__default.useCallback(function (index, value) {
+        // const arr = control._getFieldArray(name);
+        // arr[index] = {...value};
+        // control._updateFieldArray(name, arr);
+        // trigger(name);
+        // control._subjects.watch.next({});
+        setValue("".concat(name, ".").concat(index), value);
+    }, [control]);
+    function renderBody() {
+        var handleItemAdd = function () {
+            var values = __assign({}, scaffold);
+            append(values);
+            /** 开启滚动后新增元素定位到底部 */
+            if (enableScroll && tableRef) {
+                requestAnimationFrame(function () {
+                    var _a, _b;
+                    (_b = (_a = tableRef === null || tableRef === void 0 ? void 0 : tableRef.current) === null || _a === void 0 ? void 0 : _a.scrollIntoView) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                        behavior: 'smooth',
+                        block: 'end',
+                        inline: 'nearest'
+                    });
+                });
+            }
+            onItemAdd === null || onItemAdd === void 0 ? void 0 : onItemAdd(values);
+        };
+        return (React__default.createElement("div", { className: cx("Table", "InputTable-UI", className) },
+            React__default.createElement("div", { className: cx("Table-contentWrap", { 'is-fixed': enableScroll }), style: { maxHeight: enableScroll ? scroll.y : 'unset' }, ref: tBodyRef },
+                React__default.createElement("div", { className: cx('Table-content') },
+                    React__default.createElement("table", { className: cx("Table-table", tableClassName), ref: tableRef },
+                        React__default.createElement("thead", { className: cx(tableHeadClassName) },
+                            React__default.createElement("tr", null,
+                                columns.map(function (item, index) { return (React__default.createElement("th", { key: index, className: item.className }, item.thRender ? item.thRender() : item.title)); }),
+                                React__default.createElement("th", { key: "operation" }, __('Table.operation')))),
+                        React__default.createElement("tbody", { className: cx(tableBodyClassName) }, fields.length ? (fields.map(function (field, index) { return (React__default.createElement("tr", { key: field.id },
+                            React__default.createElement(InputTableRow, { key: "columns", control: control, update: lightUpdate, index: index, value: field, columns: columns, translate: __, classnames: cx, formRef: subFormRef, popOverContainer: popOverContainer }),
+                            React__default.createElement("td", { key: "operation" },
+                                React__default.createElement(Button, { level: "link", key: "delete", disabled: removable === false ||
+                                        !!(minLength && fields.length <= minLength), className: cx('Table-delBtn'), onClick: function () { return remove(index); } }, __('delete'))))); })) : (React__default.createElement("tr", null,
+                            React__default.createElement("td", { colSpan: columns.length + 1 },
+                                React__default.createElement(Icon, { icon: "desk-empty", className: cx('Table-placeholder-empty-icon', 'icon') }), placeholder !== null && placeholder !== void 0 ? placeholder : __('placeholder.noData')))))))),
+            addable !== false && (!maxLength || fields.length < maxLength) ? (React__default.createElement("div", { className: cx("InputTable-toolbar") },
+                React__default.createElement(Button, __assign({ className: cx(addButtonClassName), size: "sm" }, addButtonProps, { onClick: function () { return handleItemAdd(); } }),
+                    React__default.createElement(Icon, { icon: "plus", className: "icon" }),
+                    React__default.createElement("span", null, __(addButtonText || 'add'))), footer === null || footer === void 0 ? void 0 :
+                footer())) : null));
+    }
+    return wrap === false ? (renderBody()) : (React__default.createElement(ThemedFormField, { className: fieldClassName, label: label, labelAlign: labelAlign, labelClassName: labelClassName, description: description, mode: mode, hasError: !!((_b = errors[name]) === null || _b === void 0 ? void 0 : _b.message), errors: (_c = errors[name]) === null || _c === void 0 ? void 0 : _c.message }, renderBody()));
+}
+var InputTableRow = React__default.memo(function InputTableRow(_a) {
+    var value = _a.value, columns = _a.columns, index = _a.index, translate = _a.translate, update = _a.update, formRef = _a.formRef; _a.classnames; var popOverContainer = _a.popOverContainer;
+    var indexRef = React__default.useRef(index);
+    React__default.useEffect(function () {
+        indexRef.current = index;
+    }, [index]);
+    var methods = useSubForm(value, translate, function (data) {
+        return update(indexRef.current, data);
+    });
+    React__default.useEffect(function () {
+        formRef === null || formRef === void 0 ? void 0 : formRef(methods, value.id);
+        return function () {
+            formRef === null || formRef === void 0 ? void 0 : formRef(null, value.id);
+        };
+    }, [methods, value.id]);
+    return (React__default.createElement(React__default.Fragment, null, columns.map(function (item, colIndex) { return (React__default.createElement("td", { key: colIndex, className: item.className }, item.tdRender(__assign(__assign({}, methods), { popOverContainer: popOverContainer }), colIndex, index))); })));
+});
+var InputTable$1 = themeable(localeable(InputTable));
+
+export { InputTable, InputTableRow, InputTable$1 as default };

package/esm/components/JSONSchemaEditor.d.ts

@@ -0,0 +1,2 @@
+import JSONSchemaEditor from './schema-editor';
+export default JSONSchemaEditor;

package/esm/components/JSONSchemaEditor.js

@@ -0,0 +1,7 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import JSONSchemaEditor from './schema-editor/index.js';
+export { default } from './schema-editor/index.js';

package/esm/components/Layout.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @file Layout
+ * @description 页面布局，支持左边栏、顶部、内容区域布局。
+ * @author fex
+ *
+ * @param 参数说明：
+ * * children 会渲染在内容区。
+ * * header 头部区域
+ * * aside 边栏
+ * * asideClassName 边栏附加样式class
+ * * footer 页脚
+ * * folder 是否收起边栏
+ * * asideFixed 边栏是否为固定模式，如果是会用 position:fixed 来定位.
+ * * className 附件的样式名
+ * * contentClassName 内容区域附加样式名称
+ */
+/// <reference types="hoist-non-react-statics" />
+import React from 'react';
+import { ClassNamesFn } from 'amis-core';
+interface LayoutProps {
+    header?: boolean | React.ReactNode;
+    headerClassName?: string;
+    aside?: boolean | React.ReactNode;
+    asideClassName?: string;
+    boxed?: boolean;
+    folded?: boolean;
+    asideFixed?: boolean;
+    headerFixed?: boolean;
+    className?: string;
+    contentClassName?: string;
+    footer?: boolean | React.ReactNode;
+    offScreen?: boolean;
+    classPrefix: string;
+    classnames: ClassNamesFn;
+    size?: 'sm' | 'base' | 'md' | 'lg';
+    children?: React.ReactNode;
+    bodyClassName?: string;
+    mainClassName?: string;
+}
+export declare function Layout({ header, headerClassName, aside, asideClassName, children, className, contentClassName, folded, asideFixed, headerFixed, footer, offScreen, size, boxed, classnames: cx, bodyClassName, mainClassName }: LayoutProps): React.JSX.Element;
+declare const _default: {
+    new (props: Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps): {
+        ref: any;
+        childRef(ref: any): void;
+        getWrappedInstance(): any;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<LayoutProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<typeof Layout>;
+} & import("hoist-non-react-statics").NonReactStatics<typeof Layout, {}> & {
+    ComposedComponent: typeof Layout;
+};
+export default _default;

package/esm/components/Layout.js

@@ -0,0 +1,60 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import React__default from 'react';
+import { themeable } from 'amis-core';
+
+/**
+ * @file Layout
+ * @description 页面布局，支持左边栏、顶部、内容区域布局。
+ * @author fex
+ *
+ * @param 参数说明：
+ * * children 会渲染在内容区。
+ * * header 头部区域
+ * * aside 边栏
+ * * asideClassName 边栏附加样式class
+ * * footer 页脚
+ * * folder 是否收起边栏
+ * * asideFixed 边栏是否为固定模式，如果是会用 position:fixed 来定位.
+ * * className 附件的样式名
+ * * contentClassName 内容区域附加样式名称
+ */
+function Layout(_a) {
+    var _b;
+    var header = _a.header, headerClassName = _a.headerClassName, aside = _a.aside, _c = _a.asideClassName, asideClassName = _c === void 0 ? '' : _c, children = _a.children, className = _a.className, contentClassName = _a.contentClassName, folded = _a.folded, _d = _a.asideFixed, asideFixed = _d === void 0 ? true : _d, _e = _a.headerFixed, headerFixed = _e === void 0 ? true : _e, _f = _a.footer, footer = _f === void 0 ? false : _f, _g = _a.offScreen, offScreen = _g === void 0 ? false : _g, size = _a.size, boxed = _a.boxed, cx = _a.classnames, bodyClassName = _a.bodyClassName, mainClassName = _a.mainClassName;
+    var body = (React__default.createElement("div", { className: cx("Layout-body", contentClassName) }, children));
+    if (aside) {
+        body = (React__default.createElement("div", { className: cx('Layout-content'), role: "main" }, body));
+    }
+    React__default.useEffect(function () {
+        bodyClassName && document.body.classList.add(bodyClassName);
+        return function () {
+            bodyClassName && document.body.classList.remove(bodyClassName);
+        };
+    }, [bodyClassName]);
+    return (React__default.createElement("div", { className: cx("Layout", className, (_b = {
+                'Layout--boxed': boxed,
+                'Layout--withAside': !!aside,
+                'Layout--headerFixed': header ? headerFixed : false,
+                'Layout--asideFixed': aside ? asideFixed : false,
+                'Layout--folded': folded,
+                'Layout--offScreen': offScreen
+            },
+            _b["Layout--".concat(size)] = size,
+            _b['Layout--noFooter'] = !footer,
+            _b['Layout--noHeader'] = !header,
+            _b)) },
+        header ? (React__default.createElement("div", { className: cx('Layout-header', headerClassName) }, header)) : null,
+        React__default.createElement("div", { className: cx('Layout-main', mainClassName) },
+            aside ? (React__default.createElement("div", { className: cx("Layout-aside", asideClassName) },
+                React__default.createElement("div", { className: cx('Layout-asideWrap') },
+                    React__default.createElement("div", { id: "asideInner", className: cx('Layout-asideInner') }, aside)))) : null,
+            body),
+        footer ? (React__default.createElement("footer", { className: cx('Layout-footer'), role: "footer" }, footer)) : null));
+}
+var Layout$1 = themeable(Layout);
+
+export { Layout, Layout$1 as default };