tntd 2.6.6 → 2.7.0

package/es/tntd-form/__tests__/index.test.js

@@ -0,0 +1,957 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { useState } from 'react';
+import scrollIntoView from 'scroll-into-view-if-needed';
+import classNames from 'classnames';
+import Form from '..';
+import * as Util from '../util';
+import Button from '../../button';
+import Input from '../../input';
+import Select from '../../select';
+import Upload from '../../upload';
+import Cascader from '../../cascader';
+import Checkbox from '../../checkbox';
+import DatePicker from '../../date-picker';
+import InputNumber from '../../input-number';
+import Radio from '../../radio';
+import Switch from '../../switch';
+import TreeSelect from '../../tree-select';
+import mountTest from '../../../tests/shared/mountTest';
+import rtlTest from '../../../tests/shared/rtlTest';
+import { fireEvent, render, screen, pureRender, waitFakeTimer } from '../../../tests/utils';
+import ConfigProvider from '../../config-provider';
+import Drawer from '../../drawer';
+import zhCN from '../../locale/zh_CN';
+import Modal from '../../modal';
+const { RangePicker } = DatePicker;
+const { TextArea } = Input;
+jest.mock('scroll-into-view-if-needed');
+describe('Form', () => {
+    mountTest(Form);
+    mountTest(Form.Item);
+    rtlTest(Form);
+    rtlTest(Form.Item);
+    scrollIntoView.mockImplementation(() => { });
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+    // const change = async (
+    //   container: ReturnType<typeof render>['container'],
+    //   index: number,
+    //   value: string,
+    //   executeMockTimer: boolean,
+    // ) => {
+    //   fireEvent.change(container.querySelectorAll('input')?.[index], { target: { value } });
+    //   await sleep(200);
+    //   if (executeMockTimer) {
+    //     for (let i = 0; i < 10; i += 1) {
+    //       act(() => {
+    //         jest.runAllTimers();
+    //       });
+    //     }
+    //     await sleep(1);
+    //   }
+    // };
+    const changeValue = async (input, value, advTimer = 1000) => {
+        let element;
+        if (typeof input === 'number') {
+            element = document.querySelectorAll('input')[input];
+        }
+        expect(element).toBeTruthy();
+        fireEvent.change(element, {
+            target: {
+                value,
+            },
+        });
+        if (advTimer) {
+            await waitFakeTimer(advTimer / 20, 20);
+        }
+    };
+    beforeEach(() => {
+        document.body.innerHTML = '';
+        jest.useFakeTimers();
+        scrollIntoView.mockReset();
+    });
+    afterEach(() => {
+        errorSpy.mockReset();
+    });
+    afterAll(() => {
+        jest.clearAllTimers();
+        jest.useRealTimers();
+        errorSpy.mockRestore();
+        warnSpy.mockRestore();
+        scrollIntoView.mockRestore();
+    });
+    describe('noStyle Form.Item', () => {
+        it('should show alert when form field is required but empty', async () => {
+            const onChange = jest.fn();
+            const { container } = render(React.createElement(Form, null,
+                React.createElement(Form.Item, null,
+                    React.createElement(Form.Item, { name: "test", label: "test", initialValue: "bamboo", rules: [{ required: true }] },
+                        React.createElement(Input, { onChange: onChange })))));
+            // user type something and clear
+            await changeValue(0, 'test');
+            await changeValue(0, '');
+            // should show alert with correct message and show correct styles
+            expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent("'test' is required");
+            expect(container.querySelector('.ant-input-status-error')).toBeTruthy();
+            expect(container.querySelector('.ant-form-item-has-error')).toBeTruthy();
+            expect(onChange).toHaveBeenCalled();
+        });
+        it('should clean up', async () => {
+            const Demo = () => {
+                const [form] = Form.useForm();
+                const onChange = async () => {
+                    // Wait a while and then some logic to validate
+                    await waitFakeTimer();
+                    try {
+                        await form.validateFields();
+                    }
+                    catch (err) {
+                        // do nothing
+                    }
+                };
+                return (React.createElement(Form, { form: form, initialValues: { aaa: '2' } },
+                    React.createElement(Form.Item, { name: "aaa" },
+                        React.createElement(Input, { onChange: onChange })),
+                    React.createElement(Form.Item, { shouldUpdate: true, noStyle: true }, () => {
+                        const aaa = form.getFieldValue('aaa');
+                        if (aaa === '1') {
+                            return (React.createElement(Form.Item, { name: "bbb", rules: [{ required: true, message: 'aaa' }] },
+                                React.createElement(Input, null)));
+                        }
+                        return (React.createElement(Form.Item, null,
+                            React.createElement(Form.Item, { name: "ccc", rules: [{ required: true, message: 'ccc' }], noStyle: true },
+                                React.createElement(Input, null))));
+                    })));
+            };
+            const { container } = render(React.createElement(Demo, null));
+            await changeValue(0, '1');
+            await waitFakeTimer(2000, 2000);
+            expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent('aaa');
+            await changeValue(0, '2');
+            await waitFakeTimer(2000, 2000);
+            expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent('ccc');
+            await changeValue(0, '1');
+            await waitFakeTimer(2000, 2000);
+            expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent('aaa');
+        });
+    });
+    it('render functions require either `shouldUpdate` or `dependencies`', () => {
+        render(React.createElement(Form, null,
+            React.createElement(Form.Item, null, () => null)));
+        expect(errorSpy).toHaveBeenCalledWith('Warning: [antd: Form.Item] A `Form.Item` with a render function must have either `shouldUpdate` or `dependencies`.');
+    });
+    it("`shouldUpdate` shouldn't work with `dependencies`", () => {
+        render(React.createElement(Form, null,
+            React.createElement(Form.Item, { shouldUpdate: true, dependencies: [] }, () => null)));
+        expect(errorSpy).toHaveBeenCalledWith("Warning: [antd: Form.Item] `shouldUpdate` and `dependencies` shouldn't be used together. See https://u.ant.design/form-deps.");
+    });
+    it('`name` should not work with render props', () => {
+        render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", shouldUpdate: true }, () => null)));
+        expect(errorSpy).toHaveBeenCalledWith("Warning: [antd: Form.Item] A `Form.Item` with a render function cannot be a field, and thus cannot have a `name` prop.");
+    });
+    it('multiple children with a name prop', () => {
+        render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test" },
+                React.createElement("div", null, "one"),
+                React.createElement("div", null, "two"))));
+        expect(errorSpy).toHaveBeenCalledWith('Warning: [antd: Form.Item] A `Form.Item` with a `name` prop must have a single child element. For information on how to render more complex form items, see https://u.ant.design/complex-form-item.');
+    });
+    it('input element should have the prop aria-describedby pointing to the help id when there is a help message', () => {
+        var _a, _b;
+        const { container } = pureRender(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", help: "This is a help" },
+                React.createElement("input", null))));
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-describedby')).toBe('test_help');
+        expect((_b = container.querySelector('.ant-form-item-explain')) === null || _b === void 0 ? void 0 : _b.id).toBe('test_help');
+    });
+    it('input element should not have the prop aria-describedby pointing to the help id when there is a help message and name is not defined', () => {
+        var _a, _b;
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { help: "This is a help" },
+                React.createElement("input", null))));
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-describedby')).toBeFalsy();
+        expect((_b = container.querySelector('.ant-form-item-explain')) === null || _b === void 0 ? void 0 : _b.id).toBeFalsy();
+    });
+    it('input element should have the prop aria-describedby concatenated with the form name pointing to the help id when there is a help message', () => {
+        var _a, _b;
+        const { container } = render(React.createElement(Form, { name: "form" },
+            React.createElement(Form.Item, { name: "test", help: "This is a help" },
+                React.createElement("input", null))));
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-describedby')).toBe('form_test_help');
+        expect((_b = container.querySelector('.ant-form-item-explain')) === null || _b === void 0 ? void 0 : _b.id).toBe('form_test_help');
+    });
+    it('input element should have the prop aria-describedby pointing to the help id when there are errors', async () => {
+        var _a, _b;
+        const { container } = pureRender(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", rules: [{ len: 3 }, { type: 'number' }] },
+                React.createElement("input", null))));
+        await changeValue(0, 'Invalid number');
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-describedby')).toBe('test_help');
+        expect((_b = container.querySelector('.ant-form-item-explain')) === null || _b === void 0 ? void 0 : _b.id).toBe('test_help');
+    });
+    it('input element should have the prop aria-invalid when there are errors', async () => {
+        var _a;
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", rules: [{ len: 3 }, { type: 'number' }] },
+                React.createElement("input", null))));
+        await changeValue(0, 'Invalid number');
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-invalid')).toBe('true');
+    });
+    it('input element should have the prop aria-required when the prop `required` is true', () => {
+        var _a;
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", required: true },
+                React.createElement("input", null))));
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-required')).toBe('true');
+    });
+    it('input element should have the prop aria-required when there is a rule with required', () => {
+        var _a;
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", rules: [{ required: true }] },
+                React.createElement("input", null))));
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-required')).toBe('true');
+    });
+    it('input element should have the prop aria-describedby pointing to the extra id when there is a extra message', () => {
+        var _a, _b;
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", extra: "This is a extra message" },
+                React.createElement("input", null))));
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-describedby')).toBe('test_extra');
+        expect((_b = container.querySelector('.ant-form-item-extra')) === null || _b === void 0 ? void 0 : _b.id).toBe('test_extra');
+    });
+    it('input element should not have the prop aria-describedby pointing to the extra id when there is a extra message and name is not defined', () => {
+        var _a, _b;
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { extra: "This is a extra message" },
+                React.createElement("input", null))));
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-describedby')).toBeFalsy();
+        expect((_b = container.querySelector('.ant-form-item-extra')) === null || _b === void 0 ? void 0 : _b.id).toBeFalsy();
+    });
+    it('input element should have the prop aria-describedby pointing to the help and extra id when there is a help and extra message', () => {
+        var _a;
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", help: "This is a help", extra: "This is a extra message" },
+                React.createElement("input", null))));
+        expect((_a = container.querySelector('input')) === null || _a === void 0 ? void 0 : _a.getAttribute('aria-describedby')).toBe('test_help test_extra');
+    });
+    describe('scrollToField', () => {
+        const test = (name, genForm) => {
+            it(name, () => {
+                let callGetForm;
+                const Demo = () => {
+                    const { props, getForm } = genForm();
+                    callGetForm = getForm;
+                    return (React.createElement(Form, Object.assign({ name: "scroll" }, props),
+                        React.createElement(Form.Item, { name: "test" },
+                            React.createElement(Input, null))));
+                };
+                render(React.createElement(Demo, null));
+                expect(scrollIntoView).not.toHaveBeenCalled();
+                const form = callGetForm();
+                form.scrollToField('test', {
+                    block: 'start',
+                });
+                const inputNode = document.getElementById('scroll_test');
+                expect(scrollIntoView).toHaveBeenCalledWith(inputNode, {
+                    block: 'start',
+                    scrollMode: 'if-needed',
+                });
+            });
+        };
+        // hooks
+        test('useForm', () => {
+            const [form] = Form.useForm();
+            return {
+                props: { form },
+                getForm: () => form,
+            };
+        });
+        // ref
+        test('ref', () => {
+            let form;
+            return {
+                props: {
+                    ref: (instance) => {
+                        form = instance;
+                    },
+                },
+                getForm: () => form,
+            };
+        });
+    });
+    it('scrollToFirstError', async () => {
+        const onFinishFailed = jest.fn();
+        const { container } = render(React.createElement(Form, { scrollToFirstError: { block: 'center' }, onFinishFailed: onFinishFailed },
+            React.createElement(Form.Item, { name: "test", rules: [{ required: true }] },
+                React.createElement("input", null)),
+            React.createElement(Form.Item, null,
+                React.createElement(Button, { htmlType: "submit" }, "Submit"))));
+        expect(scrollIntoView).not.toHaveBeenCalled();
+        fireEvent.submit(container.querySelector('form'));
+        await waitFakeTimer();
+        const inputNode = document.getElementById('test');
+        expect(scrollIntoView).toHaveBeenCalledWith(inputNode, {
+            block: 'center',
+            scrollMode: 'if-needed',
+        });
+        expect(onFinishFailed).toHaveBeenCalled();
+    });
+    it('Form.Item should support data-*、aria-* and custom attribute', () => {
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { "data-text": "123", "aria-hidden": "true", cccc: "bbbb" }, "text")));
+        expect(container.firstChild).toMatchSnapshot();
+    });
+    it('warning when use `name` but children is not validate element', () => {
+        render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "warning" }, "text")));
+        expect(errorSpy).toHaveBeenCalledWith('Warning: [antd: Form.Item] `name` is only used for validate React element. If you are using Form.Item as layout display, please remove `name` instead.');
+    });
+    it('dynamic change required', async () => {
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { label: "light", name: "light", valuePropName: "checked" },
+                React.createElement("input", { type: "checkbox" })),
+            React.createElement(Form.Item, { label: "bamboo", name: "bamboo", dependencies: ['light'], rules: [({ getFieldValue }) => ({ required: getFieldValue('light') })] },
+                React.createElement("input", null))));
+        // should not show alert by default
+        expect(container.querySelector('.ant-form-item-explain')).toBeFalsy();
+        // click to change the light field value to true
+        fireEvent.click(container.querySelector('input'));
+        await waitFakeTimer();
+        // user input something and clear
+        await changeValue(1, '1');
+        await changeValue(1, '');
+        // should show alert says that the field is required
+        expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent("'bamboo' is required");
+    });
+    describe('should show related className when customize help', () => {
+        it('normal', async () => {
+            const { container } = render(React.createElement(Form, null,
+                React.createElement(Form.Item, { help: "good" },
+                    React.createElement("input", null))));
+            await waitFakeTimer();
+            expect(container.querySelector('.ant-form-item-explain')).toHaveTextContent('good');
+            expect(container.querySelector('.ant-form-item-with-help')).toBeTruthy();
+        });
+        it('empty string', async () => {
+            const { container } = render(React.createElement(Form, null,
+                React.createElement(Form.Item, { help: "" },
+                    React.createElement("input", null))));
+            await waitFakeTimer();
+            expect(container.querySelector('.ant-form-item-explain')).toHaveTextContent('');
+            expect(container.querySelector('.ant-form-item-with-help')).toBeTruthy();
+        });
+    });
+    it('warning when use v3 function', () => {
+        Form.create();
+        expect(errorSpy).toHaveBeenCalledWith('Warning: [antd: Form] antd v4 removed `Form.create`. Please remove or use `@ant-design/compatible` instead.');
+    });
+    // https://github.com/ant-design/ant-design/issues/20706
+    it('Error change should work', async () => {
+        var _a, _b;
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "name", label: "test", rules: [
+                    { required: true },
+                    {
+                        validator: (_, value) => {
+                            if (value === 'p') {
+                                return Promise.reject(new Error('not a p'));
+                            }
+                            return Promise.resolve();
+                        },
+                    },
+                ] },
+                React.createElement(Input, null))));
+        /* eslint-disable no-await-in-loop */
+        for (let i = 0; i < 3; i += 1) {
+            await changeValue(0, 'bamboo');
+            await changeValue(0, '');
+            expect((_a = container.querySelector('.ant-form-item-explain')) === null || _a === void 0 ? void 0 : _a.textContent).toEqual("'name' is required");
+            await changeValue(0, 'p');
+            expect((_b = container.querySelector('.ant-form-item-explain')) === null || _b === void 0 ? void 0 : _b.textContent).toEqual('not a p');
+        }
+        /* eslint-enable */
+    });
+    // https://github.com/ant-design/ant-design/issues/20813
+    it('should update help directly when provided', async () => {
+        const App = () => {
+            const [message, updateMessage] = React.useState('');
+            return (React.createElement(Form, null,
+                React.createElement(Form.Item, { label: "hello", help: message },
+                    React.createElement(Input, null)),
+                React.createElement(Button, { onClick: () => updateMessage('bamboo') })));
+        };
+        const { container } = render(React.createElement(App, null));
+        // should show initial text
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain')).toHaveTextContent('');
+        fireEvent.click(container.querySelector('button'));
+        // should show bamboo alert without opacity and hide first alert with opacity: 0
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain')).toHaveTextContent('bamboo');
+    });
+    it('warning when use `dependencies` but `name` is empty & children is not a render props', () => {
+        render(React.createElement(Form, null,
+            React.createElement(Form.Item, { dependencies: [] }, "text")));
+        expect(errorSpy).toHaveBeenCalledWith('Warning: [antd: Form.Item] Must set `name` or use a render function when `dependencies` is set.');
+    });
+    // https://github.com/ant-design/ant-design/issues/20948
+    it('not repeat render when Form.Item is not a real Field', async () => {
+        const shouldNotRender = jest.fn();
+        const StaticInput = ({ id, value = '', }) => {
+            shouldNotRender();
+            return React.createElement("input", { id: id, value: value });
+        };
+        const shouldRender = jest.fn();
+        const DynamicInput = ({ value = '', id, }) => {
+            shouldRender();
+            return React.createElement("input", { id: id, value: value });
+        };
+        const formRef = React.createRef();
+        const { container } = pureRender(React.createElement(Form, { ref: formRef },
+            React.createElement(Form.Item, null,
+                React.createElement(StaticInput, null)),
+            React.createElement(Form.Item, { name: "light" },
+                React.createElement(DynamicInput, { id: "changed" }))));
+        await waitFakeTimer();
+        expect(container.querySelector('#changed').value).toEqual('');
+        expect(shouldNotRender).toHaveBeenCalledTimes(1);
+        expect(shouldRender).toHaveBeenCalledTimes(1);
+        formRef.current.setFieldsValue({ light: 'bamboo' });
+        await waitFakeTimer(100, 100);
+        expect(formRef.current.getFieldsValue()).toEqual({ light: 'bamboo' });
+        expect(container.querySelector('#changed').value).toEqual('bamboo');
+        expect(shouldNotRender).toHaveBeenCalledTimes(1);
+        expect(shouldRender).toHaveBeenCalledTimes(2);
+    });
+    it('empty help should also render', () => {
+        const { container } = render(React.createElement(Form.Item, { help: "" },
+            React.createElement("input", null)));
+        expect(container.querySelectorAll('.ant-form-item-explain').length).toBeTruthy();
+    });
+    it('Form.Item with `help` should display error style when validate failed', async () => {
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", label: "test", help: "help", initialValue: "bamboo", rules: [{ required: true, message: 'message' }] },
+                React.createElement(Input, null))));
+        await changeValue(0, '');
+        expect(container.querySelector('.ant-form-item')).toHaveClass('ant-form-item-has-error');
+        expect(container.querySelector('.ant-form-item-explain').textContent).toEqual('help');
+    });
+    it('clear validation message when', async () => {
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "test", label: "test", rules: [{ required: true, message: 'message' }] },
+                React.createElement(Input, null))));
+        await changeValue(0, '1');
+        expect(container.querySelectorAll('.ant-form-item-explain').length).toBeFalsy();
+        await changeValue(0, '');
+        expect(container.querySelectorAll('.ant-form-item-explain').length).toBeTruthy();
+        await changeValue(0, '123');
+        expect(container.querySelectorAll('.ant-form-item-explain').length).toBeFalsy();
+    });
+    // https://github.com/ant-design/ant-design/issues/21167
+    it('`require` without `name`', () => {
+        const { container } = render(React.createElement(Form.Item, { label: "test", name: "test", required: true },
+            React.createElement("input", null)));
+        // expect(screen.getByTitle('test')).toHaveClass('ant-form-item-required');
+        expect(container.querySelector('.ant-form-item-required')).toBeTruthy();
+    });
+    it('0 is a validate Field', () => {
+        render(React.createElement(Form.Item, { name: 0, label: "0" },
+            React.createElement("input", null)));
+        // if getByLabelText can get element, then it is a validate field with form control and label
+        expect(screen.getByLabelText('0')).toBeInTheDocument();
+    });
+    it('`null` triggers warning and is treated as `undefined`', () => {
+        render(React.createElement(Form.Item, { name: null, label: "test" },
+            React.createElement("input", null)));
+        // if getByLabelText can get element, then it is a validate field with form control and label
+        expect(screen.queryByLabelText('test')).not.toBeInTheDocument();
+        expect(errorSpy).toHaveBeenCalledWith('Warning: [antd: Form.Item] `null` is passed as `name` property');
+    });
+    // https://github.com/ant-design/ant-design/issues/21415
+    it('should not throw error when Component.props.onChange is null', async () => {
+        const CustomComponent = () => (React.createElement("input", { onChange: null }));
+        render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "custom" },
+                React.createElement(CustomComponent, null))));
+        await changeValue(0, 'aaa');
+    });
+    it('change `help` should not warning', async () => {
+        const Demo = () => {
+            const [error, setError] = React.useState(false);
+            return (React.createElement(Form, null,
+                React.createElement(Form.Item, { help: error ? 'This is an error msg' : undefined, validateStatus: error ? 'error' : '', label: "Username", name: "username" },
+                    React.createElement("input", null)),
+                React.createElement(Form.Item, null,
+                    React.createElement("button", { type: "button", onClick: () => setError(!error) }, "Trigger"))));
+        };
+        const { container } = render(React.createElement(Demo, null));
+        fireEvent.click(container.querySelector('button'));
+        expect(errorSpy).not.toHaveBeenCalled();
+    });
+    it('`label` support template', async () => {
+        const { container } = render(
+        // eslint-disable-next-line no-template-curly-in-string
+        React.createElement(Form, { validateMessages: { required: '${label} is good!' } },
+            React.createElement(Form.Item, { name: "test", label: "Bamboo", rules: [{ required: true }] },
+                React.createElement("input", null))));
+        fireEvent.submit(container.querySelector('form'));
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent('Bamboo is good!');
+    });
+    // https://github.com/ant-design/ant-design/issues/33691
+    it('should keep upper locale in nested ConfigProvider', async () => {
+        const { container } = render(React.createElement(ConfigProvider, { locale: zhCN },
+            React.createElement(ConfigProvider, null,
+                React.createElement(Form, null,
+                    React.createElement(Form.Item, { name: "test", label: "Bamboo", rules: [{ required: true }] },
+                        React.createElement("input", null))))));
+        fireEvent.submit(container.querySelector('form'));
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent('请输入Bamboo');
+    });
+    it('`name` support template when label is not provided', async () => {
+        const { container } = render(
+        // eslint-disable-next-line no-template-curly-in-string
+        React.createElement(Form, { validateMessages: { required: '${label} is good!' } },
+            React.createElement(Form.Item, { name: "Bamboo", rules: [{ required: true }] },
+                React.createElement("input", null))));
+        fireEvent.submit(container.querySelector('form'));
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent('Bamboo is good!');
+    });
+    it('`messageVariables` support validate', async () => {
+        const { container } = render(
+        // eslint-disable-next-line no-template-curly-in-string
+        React.createElement(Form, { validateMessages: { required: '${label} is good!' } },
+            React.createElement(Form.Item, { name: "test", messageVariables: { label: 'Bamboo' }, rules: [{ required: true }] },
+                React.createElement("input", null))));
+        fireEvent.submit(container.querySelector('form'));
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent('Bamboo is good!');
+    });
+    it('validation message should has alert role', async () => {
+        // https://github.com/ant-design/ant-design/issues/25711
+        const { container } = render(
+        // eslint-disable-next-line no-template-curly-in-string
+        React.createElement(Form, { validateMessages: { required: 'name is good!' } },
+            React.createElement(Form.Item, { name: "test", rules: [{ required: true }] },
+                React.createElement("input", null)),
+            React.createElement(Form.Item, null,
+                React.createElement(Button, { htmlType: "submit" }, "Submit"))));
+        fireEvent.submit(container.querySelector('form'));
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain-error')).toHaveTextContent('name is good!');
+    });
+    it('return same form instance', async () => {
+        const instances = new Set();
+        const App = () => {
+            const [form] = Form.useForm();
+            instances.add(form);
+            const [, forceUpdate] = React.useState({});
+            return (React.createElement("button", { type: "button", onClick: () => {
+                    forceUpdate({});
+                } }, "Refresh"));
+        };
+        const { container } = pureRender(React.createElement(App, null));
+        for (let i = 0; i < 5; i += 1) {
+            fireEvent.click(container.querySelector('button'));
+            // eslint-disable-next-line no-await-in-loop
+            await waitFakeTimer();
+        }
+        expect(instances.size).toBe(1);
+    });
+    it('should avoid re-render', async () => {
+        let renderTimes = 0;
+        const MyInput = (_a) => {
+            var { value = '' } = _a, props = __rest(_a, ["value"]);
+            renderTimes += 1;
+            return React.createElement("input", Object.assign({ value: value }, props));
+        };
+        const Demo = () => (React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "username", label: "username", rules: [{ required: true }] },
+                React.createElement(MyInput, null))));
+        const { container } = pureRender(React.createElement(Demo, null));
+        renderTimes = 0;
+        await changeValue(0, 'a');
+        expect(renderTimes).toEqual(1);
+        expect(container.querySelector('input')).toHaveValue('a');
+    });
+    it('should warning with `defaultValue`', () => {
+        render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "light" },
+                React.createElement("input", { defaultValue: "should warning" }))));
+        expect(errorSpy).toHaveBeenCalledWith('Warning: [antd: Form.Item] `defaultValue` will not work on controlled Field. You should use `initialValues` of Form instead.');
+    });
+    it('should remove Field and also reset error', async () => {
+        const Demo = ({ showA }) => (React.createElement(Form, null, showA ? (React.createElement(Form.Item, { name: "a", help: "error" },
+            React.createElement("input", null))) : (React.createElement(Form.Item, { name: "b" },
+            React.createElement("input", null)))));
+        const { container, rerender } = render(React.createElement(Demo, { showA: true }));
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain')).toBeTruthy();
+        rerender(React.createElement(Demo, { showA: false }));
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain')).toBeFalsy();
+    });
+    it('no warning of initialValue & getValueProps & preserve', () => {
+        render(React.createElement(Form, null,
+            React.createElement(Form.Item, { initialValue: "bamboo", getValueProps: () => ({}), preserve: false },
+                React.createElement(Input, null))));
+        expect(errorSpy).not.toHaveBeenCalled();
+    });
+    it('should customize id when pass with id', () => {
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "light" },
+                React.createElement(Input, { id: "bamboo" }))));
+        expect(container.querySelector('input').id).toEqual('bamboo');
+    });
+    it('should trigger validate when onBlur when pass validateTrigger onBlur', async () => {
+        const { container } = render(React.createElement(Form, { validateTrigger: "onBlur" },
+            React.createElement(Form.Item, { name: "light", label: "light", rules: [{ len: 3 }] },
+                React.createElement(Input, null))));
+        // type a invalidate value, not trigger validation
+        await changeValue(0, '7777');
+        expect(container.querySelector('.ant-form-item-explain')).toBeFalsy();
+        // tab(onBlur) the input field, trigger and see the alert
+        fireEvent.blur(container.querySelector('input'));
+        await waitFakeTimer();
+        expect(container.querySelector('.ant-form-item-explain')).toBeTruthy();
+    });
+    describe('Form item hidden', () => {
+        it('should work', () => {
+            const { container } = render(React.createElement(Form, null,
+                React.createElement(Form.Item, { name: "light", hidden: true },
+                    React.createElement(Input, null))));
+            expect(container.firstChild).toMatchSnapshot();
+        });
+        it('noStyle should not work when hidden', () => {
+            const { container } = render(React.createElement(Form, null,
+                React.createElement(Form.Item, { name: "light", hidden: true, noStyle: true },
+                    React.createElement(Input, null))));
+            expect(container.firstChild).toMatchSnapshot();
+        });
+    });
+    it('legacy hideRequiredMark', () => {
+        const { container } = render(React.createElement(Form, { hideRequiredMark: true, role: "form" },
+            React.createElement(Form.Item, { name: "light", label: "light", required: true },
+                React.createElement(Input, null))));
+        expect(container.querySelector('form')).toHaveClass('ant-form-hide-required-mark');
+    });
+    it('form should support disabled', () => {
+        const App = () => (React.createElement(Form, { labelCol: { span: 4 }, wrapperCol: { span: 14 }, layout: "horizontal", disabled: true },
+            React.createElement(Form.Item, { label: "Form disabled", name: "disabled", valuePropName: "checked" },
+                React.createElement(Checkbox, null, "disabled")),
+            React.createElement(Form.Item, { label: "Radio" },
+                React.createElement(Radio.Group, null,
+                    React.createElement(Radio, { value: "apple" }, "Apple"),
+                    React.createElement(Radio, { value: "pear" }, "Pear"))),
+            React.createElement(Form.Item, { label: "Input" },
+                React.createElement(Input, null)),
+            React.createElement(Form.Item, { label: "Select" },
+                React.createElement(Select, null,
+                    React.createElement(Select.Option, { value: "demo" }, "Demo"))),
+            React.createElement(Form.Item, { label: "TreeSelect" },
+                React.createElement(TreeSelect, { treeData: [
+                        {
+                            title: 'Light',
+                            value: 'light',
+                            children: [{ title: 'Bamboo', value: 'bamboo' }],
+                        },
+                    ] })),
+            React.createElement(Form.Item, { label: "Cascader" },
+                React.createElement(Cascader, { options: [
+                        {
+                            value: 'zhejiang',
+                            label: 'Zhejiang',
+                            children: [{ value: 'hangzhou', label: 'Hangzhou' }],
+                        },
+                    ] })),
+            React.createElement(Form.Item, { label: "DatePicker" },
+                React.createElement(DatePicker, null)),
+            React.createElement(Form.Item, { label: "RangePicker" },
+                React.createElement(RangePicker, null)),
+            React.createElement(Form.Item, { label: "InputNumber" },
+                React.createElement(InputNumber, null)),
+            React.createElement(Form.Item, { label: "TextArea" },
+                React.createElement(TextArea, { rows: 4 })),
+            React.createElement(Form.Item, { label: "Switch", valuePropName: "checked" },
+                React.createElement(Switch, null)),
+            React.createElement(Form.Item, { label: "Upload", valuePropName: "fileList" },
+                React.createElement(Upload, null)),
+            React.createElement(Form.Item, { label: "Button" },
+                React.createElement(Button, null, "Button"))));
+        const { container } = render(React.createElement(App, null));
+        expect(container.firstChild).toMatchSnapshot();
+    });
+    it('_internalItemRender api test', () => {
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "light", 
+                // @ts-ignore
+                _internalItemRender: {
+                    mark: 'pro_table_render',
+                    render: (_, doms) => (React.createElement("div", null,
+                        React.createElement("h1", null, "warning title"),
+                        doms.input,
+                        doms.errorList,
+                        doms.extra)),
+                } },
+                React.createElement("input", { defaultValue: "should warning" }))));
+        expect(container.querySelector('h1')).toHaveTextContent(/warning title/i);
+    });
+    it('Form Item element id will auto add form_item prefix if form name is empty and item name is in the black list', async () => {
+        const mockFn = jest.spyOn(Util, 'getFieldId');
+        const itemName = 'parentNode';
+        // mock getFieldId old logic,if form name is empty ,and item name is parentNode,will get parentNode
+        mockFn.mockImplementation(() => itemName);
+        const { Option } = Select;
+        const Demo = () => {
+            const [open, setOpen] = useState(false);
+            return (React.createElement(React.Fragment, null,
+                React.createElement(Form, null,
+                    React.createElement(Form.Item, { name: itemName, label: itemName },
+                        React.createElement(Select, { className: "form_item_parentNode", defaultValue: "lucy", open: open, style: { width: 120 } },
+                            React.createElement(Option, { value: "jack" }, "Jack"),
+                            React.createElement(Option, { value: "lucy" }, "Lucy"),
+                            React.createElement(Option, { value: "Yiminghe" }, "yiminghe")))),
+                React.createElement("button", { type: "button", onClick: () => {
+                        setOpen(true);
+                    } }, open ? 'show' : 'hidden')));
+        };
+        const { container, rerender } = render(React.createElement(Demo, null));
+        expect(mockFn).toHaveBeenCalled();
+        expect(Util.getFieldId()).toBe(itemName);
+        // make sure input id is parentNode
+        expect(screen.getByLabelText(itemName)).toHaveAccessibleName(itemName);
+        fireEvent.click(container.querySelector('button'));
+        await waitFakeTimer();
+        expect(container.querySelector('button')).toHaveTextContent('show');
+        mockFn.mockRestore();
+        rerender(React.createElement(Demo, null));
+        expect(screen.getByLabelText(itemName)).toBeInTheDocument();
+    });
+    describe('tooltip', () => {
+        it('ReactNode', async () => {
+            const { container } = render(React.createElement(Form, null,
+                React.createElement(Form.Item, { label: "light", tooltip: React.createElement("span", null, "Bamboo") },
+                    React.createElement(Input, null))));
+            fireEvent.mouseEnter(container.querySelector('.anticon-question-circle'));
+            await waitFakeTimer();
+            expect(container.querySelector('.ant-tooltip-inner')).toHaveTextContent('Bamboo');
+        });
+        it('config tooltip should show when hover on icon', async () => {
+            const { container } = render(React.createElement(Form, null,
+                React.createElement(Form.Item, { label: "light", tooltip: { title: 'Bamboo' } },
+                    React.createElement(Input, null))));
+            fireEvent.mouseEnter(container.querySelector('.anticon-question-circle'));
+            await waitFakeTimer();
+            expect(container.querySelector('.ant-tooltip-inner')).toHaveTextContent('Bamboo');
+        });
+    });
+    it('warningOnly validate', async () => {
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, null,
+                React.createElement(Form.Item, { name: "test", label: "test", initialValue: "bamboo", rules: [{ required: true, warningOnly: true }] },
+                    React.createElement(Input, null)))));
+        await changeValue(0, 'test');
+        await changeValue(0, '');
+        expect(container.querySelector('.ant-form-item-with-help')).toBeTruthy();
+        expect(container.querySelector('.ant-form-item-has-warning')).toBeTruthy();
+    });
+    it('not warning when remove on validate', async () => {
+        let rejectFn = jest.fn();
+        const { unmount } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, null,
+                React.createElement(Form.Item, { noStyle: true, name: "test", initialValue: "bamboo", rules: [
+                        {
+                            validator: () => new Promise((_, reject) => {
+                                rejectFn = reject;
+                            }),
+                        },
+                    ] },
+                    React.createElement(Input, null)))));
+        await changeValue(0, '');
+        unmount();
+        // Delay validate failed
+        rejectFn(new Error('delay failed'));
+        expect(errorSpy).not.toHaveBeenCalled();
+    });
+    describe('form colon', () => {
+        it('default colon', () => {
+            render(React.createElement(Form, null,
+                React.createElement(Form.Item, { label: "\u59D3\u540D", name: "\u59D3\u540D" },
+                    React.createElement("input", null))));
+            expect(screen.getByText('姓名')).not.toHaveClass('ant-form-item-no-colon');
+        });
+        it('set Form.Item colon false', () => {
+            render(React.createElement(Form, { colon: true },
+                React.createElement(Form.Item, { colon: false, label: "\u59D3\u540D", name: "\u59D3\u540D" },
+                    React.createElement(Input, null))));
+            expect(screen.getByText('姓名')).toHaveClass('ant-form-item-no-colon');
+        });
+        it('set Form colon false', () => {
+            render(React.createElement(Form, { colon: false },
+                React.createElement(Form.Item, { label: "\u59D3\u540D", name: "\u59D3\u540D" },
+                    React.createElement(Input, null))));
+            expect(screen.getByText('姓名')).toHaveClass('ant-form-item-no-colon');
+        });
+    });
+    it('useFormInstance', () => {
+        let formInstance;
+        let subFormInstance;
+        const Sub = () => {
+            const formSub = Form.useFormInstance();
+            subFormInstance = formSub;
+            return null;
+        };
+        const Demo = () => {
+            const [form] = Form.useForm();
+            formInstance = form;
+            return (React.createElement(Form, { form: form },
+                React.createElement(Sub, null)));
+        };
+        render(React.createElement(Demo, null));
+        expect(subFormInstance).toBe(formInstance);
+    });
+    it('noStyle should not affect status', () => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const Demo = () => (React.createElement(Form, null,
+            React.createElement(Form.Item, { validateStatus: "error", noStyle: true },
+                React.createElement(Select, { className: "custom-select" })),
+            React.createElement(Form.Item, { validateStatus: "error" },
+                React.createElement(Form.Item, { noStyle: true },
+                    React.createElement(Select, { className: "custom-select-b" }))),
+            React.createElement(Form.Item, { validateStatus: "error" },
+                React.createElement(Form.Item, { noStyle: true, validateStatus: "warning" },
+                    React.createElement(Select, { className: "custom-select-c" }))),
+            React.createElement(Form.Item, { noStyle: true },
+                React.createElement(Form.Item, { validateStatus: "warning" },
+                    React.createElement(Select, { className: "custom-select-d" })))));
+        const { container } = render(React.createElement(Demo, null));
+        expect((_a = container.querySelector('.custom-select')) === null || _a === void 0 ? void 0 : _a.className).not.toContain('status-error');
+        expect((_b = container.querySelector('.custom-select')) === null || _b === void 0 ? void 0 : _b.className).not.toContain('in-form-item');
+        expect((_c = container.querySelector('.custom-select-b')) === null || _c === void 0 ? void 0 : _c.className).toContain('status-error');
+        expect((_d = container.querySelector('.custom-select-b')) === null || _d === void 0 ? void 0 : _d.className).toContain('in-form-item');
+        expect((_e = container.querySelector('.custom-select-c')) === null || _e === void 0 ? void 0 : _e.className).toContain('status-error');
+        expect((_f = container.querySelector('.custom-select-c')) === null || _f === void 0 ? void 0 : _f.className).toContain('in-form-item');
+        expect((_g = container.querySelector('.custom-select-d')) === null || _g === void 0 ? void 0 : _g.className).toContain('status-warning');
+        expect((_h = container.querySelector('.custom-select-d')) === null || _h === void 0 ? void 0 : _h.className).toContain('in-form-item');
+    });
+    it('should not affect Popup children style', () => {
+        var _a, _b, _c, _d;
+        const Demo = () => (React.createElement(Form, null,
+            React.createElement(Form.Item, { labelCol: 4, validateStatus: "error" },
+                React.createElement(Modal, { visible: true },
+                    React.createElement(Select, { className: "modal-select" }))),
+            React.createElement(Form.Item, { validateStatus: "error" },
+                React.createElement(Drawer, { visible: true },
+                    React.createElement(Select, { className: "drawer-select" })))));
+        const { container } = render(React.createElement(Demo, null), { container: document.body });
+        expect((_a = container.querySelector('.modal-select')) === null || _a === void 0 ? void 0 : _a.className).not.toContain('in-form-item');
+        expect((_b = container.querySelector('.modal-select')) === null || _b === void 0 ? void 0 : _b.className).not.toContain('status-error');
+        expect((_c = container.querySelector('.drawer-select')) === null || _c === void 0 ? void 0 : _c.className).not.toContain('in-form-item');
+        expect((_d = container.querySelector('.drawer-select')) === null || _d === void 0 ? void 0 : _d.className).not.toContain('status-error');
+    });
+    it('Form.Item.useStatus should work', async () => {
+        var _a, _b, _c, _d, _e;
+        const { Item: { useStatus }, } = Form;
+        const CustomInput = ({ className, value, }) => {
+            const { status } = useStatus();
+            return React.createElement("div", { className: classNames(className, `custom-input-status-${status}`) }, value);
+        };
+        const Demo = () => {
+            const [form] = Form.useForm();
+            return (React.createElement(Form, { form: form, name: "my-form" },
+                React.createElement(Form.Item, { name: "required", rules: [{ required: true }] },
+                    React.createElement(CustomInput, { className: "custom-input-required", value: "" })),
+                React.createElement(Form.Item, { name: "warning", validateStatus: "warning" },
+                    React.createElement(CustomInput, { className: "custom-input-warning" })),
+                React.createElement(Form.Item, { name: "normal" },
+                    React.createElement(CustomInput, { className: "custom-input" })),
+                React.createElement(CustomInput, { className: "custom-input-wrong" }),
+                React.createElement(Button, { onClick: () => form.submit(), className: "submit-button" }, "Submit")));
+        };
+        const { container } = render(React.createElement(Demo, null));
+        expect((_a = container.querySelector('.custom-input-required')) === null || _a === void 0 ? void 0 : _a.classList).toContain('custom-input-status-');
+        expect((_b = container.querySelector('.custom-input-warning')) === null || _b === void 0 ? void 0 : _b.classList).toContain('custom-input-status-warning');
+        expect((_c = container.querySelector('.custom-input')) === null || _c === void 0 ? void 0 : _c.classList).toContain('custom-input-status-');
+        expect((_d = container.querySelector('.custom-input-wrong')) === null || _d === void 0 ? void 0 : _d.classList).toContain('custom-input-status-undefined');
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Form.Item.useStatus should be used under Form.Item component.'));
+        fireEvent.click(container.querySelector('.submit-button'));
+        await waitFakeTimer();
+        expect((_e = container.querySelector('.custom-input-required')) === null || _e === void 0 ? void 0 : _e.classList).toContain('custom-input-status-error');
+    });
+    it('item customize margin', async () => {
+        const computeSpy = jest
+            .spyOn(window, 'getComputedStyle')
+            .mockImplementation(() => ({ marginBottom: 24 }));
+        const { container } = render(React.createElement(Form, null,
+            React.createElement(Form.Item, { name: "required", initialValue: "bamboo", rules: [{ required: true }] },
+                React.createElement(Input, null))));
+        await changeValue(0, '');
+        computeSpy.mockRestore();
+        expect(container.querySelector('.ant-form-item-margin-offset')).toHaveStyle({
+            marginBottom: -24,
+        });
+    });
+    it('form child components should be given priority to own disabled props when it in a disabled form', () => {
+        const props = {
+            name: 'file',
+            action: 'https://www.mocky.io/v2/5cc8019d300000980a055e76',
+            headers: {
+                authorization: 'authorization-text',
+            },
+            capture: true,
+        };
+        const renderComps = (disabled) => [
+            React.createElement(Button, { key: "Button", disabled: disabled, type: "primary", htmlType: "submit" }, "test"),
+            React.createElement(Cascader, { key: "Cascader", disabled: disabled, options: [] }),
+            React.createElement(Checkbox, { key: "Checkbox", disabled: disabled }),
+            React.createElement(Checkbox.Group, { key: "CheckboxGroup", disabled: disabled, options: [
+                    { label: 'male', value: 0 },
+                    { label: 'female', value: 1 },
+                ] }),
+            React.createElement(InputNumber, { key: "InputNumber", disabled: disabled }),
+            React.createElement(Input, { key: "Input", disabled: disabled }),
+            React.createElement(Select, { key: "Select", disabled: disabled }),
+            React.createElement(Switch, { key: "Switch", disabled: disabled }),
+            React.createElement(TreeSelect, { key: "TreeSelect", disabled: disabled }),
+            React.createElement(Upload, Object.assign({ key: "Upload" }, props, { disabled: disabled }),
+                React.createElement(Button, { disabled: disabled }, "Click to Upload")),
+            React.createElement(DatePicker, { key: "DatePicker", disabled: disabled }),
+            React.createElement(DatePicker.RangePicker, { key: "DatePicker.RangePicker", disabled: disabled }),
+            React.createElement(DatePicker.MonthPicker, { key: "DatePicker.MonthPicker", disabled: disabled }),
+            React.createElement(DatePicker.QuarterPicker, { key: "DatePicker.QuarterPicker", disabled: disabled }),
+            React.createElement(DatePicker.WeekPicker, { key: "DatePicker.WeekPicker", disabled: disabled }),
+            React.createElement(DatePicker.YearPicker, { key: "DatePicker.YearPicker", disabled: disabled }),
+            React.createElement(DatePicker.TimePicker, { key: "DatePicker.TimePicker", disabled: disabled }),
+        ];
+        const App = () => React.createElement(Form, { disabled: true }, renderComps(false));
+        const wrapper = render(React.createElement(App, null));
+        expect(wrapper.container.querySelectorAll('[disabled]').length).toBe(0);
+        const App2 = () => React.createElement(Form, { disabled: true }, renderComps());
+        const wrapper2 = render(React.createElement(App2, null));
+        // 时间范围组件中会有两个 input 框，因此虽然上述只有 18 个组件，但，实际有 19 个 带有 disabled 属性的表单组件
+        expect(wrapper2.container.querySelectorAll('[disabled]').length).toBe(19);
+        const App3 = () => React.createElement(Form, { disabled: true }, renderComps(true));
+        const wrapper3 = render(React.createElement(App3, null));
+        expect(wrapper3.container.querySelectorAll('[disabled]').length).toBe(19);
+        const App4 = () => React.createElement(Form, null, renderComps(true));
+        const wrapper4 = render(React.createElement(App4, null));
+        expect(wrapper4.container.querySelectorAll('[disabled]').length).toBe(19);
+        const App5 = () => React.createElement(Form, null, renderComps());
+        const wrapper5 = render(React.createElement(App5, null));
+        expect(wrapper5.container.querySelectorAll('[disabled]').length).toBe(0);
+    });
+});
+//# sourceMappingURL=index.test.js.map