@akinon/akiform-builder 0.8.0 → 1.0.1

package/dist/esm/__tests__/akiform-builder.test.js

@@ -0,0 +1,1430 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useController } from '@akinon/akiform';
+import { akival } from '@akinon/akival';
+import { fireEvent, render, screen, userEvent, waitFor } from '@akinon/utils';
+import * as React from 'react';
+import { act } from 'react';
+import { AkiformBuilder, THROTTLE_DELAY } from '../src/akiform-builder';
+import { field } from '../src/field-builder';
+describe('AkiformBuilder', () => {
+    const mockOnSubmit = vi.fn();
+    const mockOnReset = vi.fn();
+    const mockOnValueChange = vi.fn();
+    const expandCollapsable = () => __awaiter(void 0, void 0, void 0, function* () {
+        const user = userEvent.setup();
+        const expandIcons = (yield screen.findAllByRole('button')).filter(el => el.className.includes('akinon-collapse-expand-icon'));
+        for (const expandIcon of expandIcons) {
+            yield user.click(expandIcon);
+        }
+    });
+    const defaultFields = [
+        {
+            key: 'name',
+            label: 'Name',
+            type: 'text',
+            placeholder: 'Enter your name'
+        },
+        {
+            key: 'age',
+            label: 'Age',
+            type: 'number',
+            placeholder: 'Enter your age',
+            help: 'Description text 2'
+        }
+    ];
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('AkiformBuilder in uncontrolled mode', () => {
+        it('renders form fields correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const newDefaultFields = defaultFields.map((field, key) => (Object.assign(Object.assign({}, field), { help: `Description text ${key}`, labelDescription: `Label description text ${key}` })));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: newDefaultFields, onSubmit: mockOnSubmit }));
+            }));
+            for (const field of newDefaultFields) {
+                if (field.label) {
+                    expect(screen.getByText(field.label)).toBeInTheDocument();
+                }
+                if (field.placeholder) {
+                    expect(screen.getByPlaceholderText(field.placeholder)).toBeInTheDocument();
+                }
+                expect(screen.getByText(field.help)).toBeInTheDocument();
+                expect(screen.getByText(field.labelDescription)).toBeInTheDocument();
+            }
+        }));
+        it('renders form fields correctly with row and column fields', () => __awaiter(void 0, void 0, void 0, function* () {
+            const newDefaultFields = [
+                {
+                    type: 'row',
+                    key: 'mainrow',
+                    rowProps: {
+                        align: 'middle'
+                    },
+                    columnFields: [
+                        {
+                            type: 'column',
+                            key: 'col1',
+                            columnProps: {
+                                span: '24'
+                            },
+                            fields: [
+                                {
+                                    type: 'row',
+                                    key: 'row1',
+                                    columnFields: [
+                                        {
+                                            type: 'column',
+                                            key: 'col1_1',
+                                            fields: [
+                                                {
+                                                    type: 'text',
+                                                    key: 'test1',
+                                                    label: 'Test Field 1'
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                },
+                                {
+                                    type: 'row',
+                                    key: 'row2',
+                                    columnFields: [
+                                        {
+                                            type: 'column',
+                                            key: 'col2_1',
+                                            fields: [
+                                                {
+                                                    type: 'text',
+                                                    key: 'test2',
+                                                    label: 'Test Field 2'
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            type: 'column',
+                                            key: 'col2_2',
+                                            fields: [
+                                                {
+                                                    type: 'text',
+                                                    key: 'test3',
+                                                    label: 'Test Field 3'
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: newDefaultFields, onSubmit: mockOnSubmit }));
+            }));
+            // Check fields
+            expect(screen.getByLabelText('Test Field 1')).toBeInTheDocument();
+            expect(screen.getByLabelText('Test Field 2')).toBeInTheDocument();
+            expect(screen.getByLabelText('Test Field 3')).toBeInTheDocument();
+            // Check row and column count
+            expect(document.querySelectorAll('.akinon-col')).toHaveLength(11);
+            expect(document.querySelectorAll('.akinon-row')).toHaveLength(7);
+            // Check props
+            expect(document.querySelector('.akinon-row-middle')).toBeInTheDocument();
+            expect(document.querySelector('.akinon-col-24')).toBeInTheDocument();
+        }));
+        it('handles form with custom field and onChange', () => __awaiter(void 0, void 0, void 0, function* () {
+            const CustomComponent = ({ field, control }) => {
+                const { field: controllerField } = useController({
+                    name: field.key,
+                    control
+                });
+                return React.createElement("input", Object.assign({ "data-testid": "custom-input" }, controllerField));
+            };
+            const fields = [
+                {
+                    key: 'customField',
+                    label: 'Custom Field',
+                    type: 'custom',
+                    render: ({ field, formValues, control }) => (React.createElement(CustomComponent, { field: field, formValues: formValues, control: control }))
+                }
+            ];
+            const onValueChangeMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: mockOnSubmit, onValueChange: onValueChangeMock }));
+            }));
+            const customInput = screen.getByTestId('custom-input');
+            expect(customInput).toBeInTheDocument();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                yield userEvent.type(customInput, 'test value');
+            }));
+            yield waitFor(() => {
+                expect(onValueChangeMock).toHaveBeenCalledWith(expect.objectContaining({
+                    customField: 'test value'
+                }));
+            });
+        }));
+        it('resets form when reset button is clicked', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: mockOnSubmit, onReset: mockOnReset, showResetButton: true }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Name'), {
+                    target: { value: 'John Doe' }
+                });
+                fireEvent.change(screen.getByLabelText('Age'), {
+                    target: { value: '30' }
+                });
+                fireEvent.click(screen.getByText('RESET'));
+            }));
+            yield waitFor(() => {
+                expect(mockOnReset).toHaveBeenCalled();
+                expect(screen.getByLabelText('Name')).toHaveValue('');
+                expect(screen.getByLabelText('Age')).toHaveValue('');
+            });
+        }));
+        it('exposes reset method through ref', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ref = React.createRef();
+            const onResetMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { ref: ref, fields: defaultFields, onSubmit: mockOnSubmit, onReset: onResetMock }));
+            }));
+            // Fill in some values
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Name'), {
+                    target: { value: 'John Doe' }
+                });
+            }));
+            // Call reset through ref
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                var _a;
+                (_a = ref.current) === null || _a === void 0 ? void 0 : _a.reset();
+            }));
+            // Check if form is reset and onReset is called
+            expect(screen.getByLabelText('Name')).toHaveValue('');
+            expect(onResetMock).toHaveBeenCalled();
+            // Test partial reset
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Name'), {
+                    target: { value: 'John Doe' }
+                });
+                fireEvent.change(screen.getByLabelText('Age'), {
+                    target: { value: '30' }
+                });
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                var _a;
+                (_a = ref.current) === null || _a === void 0 ? void 0 : _a.reset({ name: 'Jane Doe' });
+            }));
+            expect(screen.getByLabelText('Name')).toHaveValue('Jane Doe');
+            expect(screen.getByLabelText('Age')).toHaveValue('30');
+        }));
+        it('calls onValueChange when form values change in uncontrolled mode', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: mockOnSubmit, onValueChange: mockOnValueChange }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Name'), {
+                    target: { value: 'John Doe' }
+                });
+            }));
+            yield waitFor(() => {
+                expect(mockOnValueChange).toHaveBeenCalledWith(expect.objectContaining({
+                    name: 'John Doe'
+                }));
+            });
+        }));
+        it('applies throttling in uncontrolled mode', () => __awaiter(void 0, void 0, void 0, function* () {
+            vi.useFakeTimers();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: mockOnSubmit, onValueChange: mockOnValueChange }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Name'), {
+                    target: { value: 'John Doe' }
+                });
+            }));
+            expect(mockOnValueChange).not.toHaveBeenCalled();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                vi.advanceTimersByTime(THROTTLE_DELAY);
+            }));
+            expect(mockOnValueChange).toHaveBeenCalledWith(expect.objectContaining({ name: 'John Doe' }));
+            vi.useRealTimers();
+        }));
+        it('renders different field types correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                {
+                    key: 'name',
+                    label: 'Name',
+                    type: 'text',
+                    help: 'Help text',
+                    labelDescription: 'Label description text',
+                    placeholder: 'Enter your name'
+                },
+                { key: 'age', label: 'Age', type: 'number' },
+                {
+                    key: 'gender',
+                    label: 'Gender',
+                    type: 'select',
+                    options: [
+                        { value: 'male', label: 'Male' },
+                        { value: 'female', label: 'Female' }
+                    ]
+                },
+                { key: 'subscribe', label: 'Subscribe', type: 'checkbox' },
+                { key: 'birthdate', label: 'Birth Date', type: 'date' },
+                { key: 'bio', label: 'Biography', type: 'textarea' }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: mockOnSubmit }));
+            }));
+            expect(screen.getByPlaceholderText('Enter your name')).toHaveAttribute('type', 'text');
+            expect(screen.getByText('Help text')).toBeInTheDocument();
+            expect(screen.getByText('Label description text')).toBeInTheDocument();
+            expect(screen.getByLabelText('Age')).toHaveClass('akinon-input-number-input');
+            expect(screen.getByLabelText('Gender')).toBeInTheDocument();
+            expect(screen.getByLabelText('Subscribe')).toHaveAttribute('type', 'checkbox');
+            expect(screen.getByLabelText('Birth Date')).toBeInTheDocument();
+            expect(screen.getByLabelText('Biography')).toBeInTheDocument();
+        }));
+        it('renders field array correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const fields = [
+                field()
+                    .key('addresses')
+                    .label('Addresses')
+                    .type('fieldArray')
+                    .defaultExpanded(true)
+                    .fields([
+                    field()
+                        .key('street')
+                        .label('Street')
+                        .type('text')
+                        .help('Help text')
+                        .labelDescription('Label description text')
+                        .build(),
+                    field().key('city').label('City').type('text').build()
+                ])
+                    .build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: mockOnSubmit }));
+            }));
+            expect(screen.getByText('Add Addresses')).toBeInTheDocument();
+            yield user.click(screen.getByTestId('addresses-add-button'));
+            yield expandCollapsable();
+            expect(screen.getAllByText('Street')).toHaveLength(1);
+            expect(screen.getAllByText('City')).toHaveLength(1);
+            expect(screen.getByText('Help text')).toBeInTheDocument();
+            expect(screen.getByText('Label description text')).toBeInTheDocument();
+        }));
+        it('handles form with field array and nested validation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const fields = [
+                {
+                    key: 'items',
+                    label: 'Items',
+                    type: 'fieldArray',
+                    fields: [
+                        {
+                            key: 'name',
+                            label: 'Item Name',
+                            type: 'text',
+                            validation: akival.string().required('Item name is required')
+                        },
+                        {
+                            key: 'quantity',
+                            label: 'Quantity',
+                            type: 'number',
+                            validation: akival.number().min(1, 'Quantity must be at least 1')
+                        }
+                    ]
+                }
+            ];
+            const onSubmitMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: onSubmitMock }));
+            }));
+            // Add an item
+            yield user.click(screen.getByTestId('items-add-button'));
+            // Try to submit without filling required fields
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            yield waitFor(() => {
+                expect(screen.getByText('An error occurred in here')).toBeInTheDocument();
+                expect(onSubmitMock).not.toHaveBeenCalled();
+            });
+            yield expandCollapsable();
+            // Fill in valid data
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                const nameInput = screen.getByRole('textbox', { name: /item name/i });
+                const quantityInput = screen.getByRole('spinbutton', {
+                    name: /quantity/i
+                });
+                yield userEvent.type(nameInput, 'Test Item');
+                yield userEvent.type(quantityInput, '2');
+            }));
+            // Submit the form
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            yield waitFor(() => {
+                expect(onSubmitMock).toHaveBeenCalledWith(expect.objectContaining({
+                    items: [{ name: 'Test Item', quantity: 2 }]
+                }), expect.anything());
+            });
+        }));
+        it('handles field array operations correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const fields = [
+                {
+                    key: 'items',
+                    label: 'Items',
+                    type: 'fieldArray',
+                    fields: [
+                        { key: 'name', label: 'Item Name', type: 'text' },
+                        { key: 'quantity', label: 'Quantity', type: 'number' }
+                    ]
+                }
+            ];
+            const TestComponent = () => {
+                const [formValues, setFormValues] = React.useState({});
+                return (React.createElement(React.Fragment, null,
+                    React.createElement(AkiformBuilder, { fields: fields, onSubmit: mockOnSubmit, onValueChange: values => {
+                            setFormValues(values);
+                        } }),
+                    React.createElement("div", { "data-testid": "form-values" }, JSON.stringify(formValues))));
+            };
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(TestComponent, null));
+            }));
+            // Add an item
+            yield user.click(screen.getByTestId('items-add-button'));
+            yield expandCollapsable();
+            // Fill in the fields
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Item Name'), {
+                    target: { value: 'Test Item' }
+                });
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Quantity'), {
+                    target: { value: '5' }
+                });
+            }));
+            // Wait for the form values to update
+            yield waitFor(() => {
+                const formValuesElement = screen.getByTestId('form-values');
+                const formValues = JSON.parse(formValuesElement.textContent || '{}');
+                expect(formValues).toEqual(expect.objectContaining({
+                    items: [{ name: 'Test Item', quantity: 5 }]
+                }));
+            });
+            // Submit the form
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            // Check the submitted values
+            yield waitFor(() => {
+                expect(mockOnSubmit).toHaveBeenCalledWith(expect.objectContaining({
+                    items: [{ name: 'Test Item', quantity: 5 }]
+                }), expect.anything());
+            });
+        }));
+        it('applies layout options correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: mockOnSubmit, layout: "horizontal", layoutOptions: { labelCol: { span: 8 }, wrapperCol: { span: 16 } } }));
+            }));
+            const form = screen.getByTestId('akiform-builder');
+            expect(form).toHaveClass('akinon-form-horizontal');
+        }));
+        it('conditionally renders and disables fields', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                { key: 'showField', label: 'Show Field', type: 'checkbox' },
+                {
+                    key: 'conditionalField',
+                    label: 'Conditional Field',
+                    type: 'text',
+                    config: { visible: values => values.showField }
+                },
+                { key: 'enableField', label: 'Enable Field', type: 'checkbox' },
+                {
+                    key: 'disableableField',
+                    label: 'Disableable Field',
+                    type: 'text',
+                    config: { disabled: values => !values.enableField }
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: mockOnSubmit }));
+            }));
+            expect(screen.queryByLabelText('Conditional Field')).not.toBeInTheDocument();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.click(screen.getByLabelText('Show Field'));
+            }));
+            expect(screen.getByLabelText('Conditional Field')).toBeInTheDocument();
+            expect(screen.getByLabelText('Disableable Field')).toBeDisabled();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.click(screen.getByLabelText('Enable Field'));
+            }));
+            expect(screen.getByLabelText('Disableable Field')).not.toBeDisabled();
+        }));
+        it('applies custom validation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                {
+                    key: 'email',
+                    label: 'Email',
+                    type: 'text',
+                    validation: akival.string().email('Invalid email format')
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: mockOnSubmit }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByRole('textbox', { name: /email/i }), {
+                    target: { value: 'invalid-email' }
+                });
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            yield waitFor(() => {
+                expect(screen.getByText('Invalid email format')).toBeInTheDocument();
+            });
+        }));
+        it('resets form using ref', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ref = React.createRef();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { ref: ref, fields: defaultFields, onSubmit: mockOnSubmit }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Name'), {
+                    target: { value: 'John Doe' }
+                });
+                fireEvent.change(screen.getByLabelText('Age'), {
+                    target: { value: '30' }
+                });
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                var _a;
+                (_a = ref.current) === null || _a === void 0 ? void 0 : _a.reset();
+            }));
+            expect(screen.getByLabelText('Name')).toHaveValue('');
+            expect(screen.getByLabelText('Age')).toHaveValue('');
+        }));
+        it('displays error states', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                {
+                    key: 'name',
+                    label: 'Name',
+                    type: 'text',
+                    validation: akival.string().required('Name is required')
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: mockOnSubmit }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            yield waitFor(() => {
+                expect(screen.getByText('Name is required')).toBeInTheDocument();
+            });
+        }));
+        it('handles form submission', () => __awaiter(void 0, void 0, void 0, function* () {
+            const onSubmit = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: onSubmit }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Name'), {
+                    target: { value: 'John Doe' }
+                });
+                fireEvent.change(screen.getByLabelText('Age'), {
+                    target: { value: '30' }
+                });
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            yield waitFor(() => {
+                expect(onSubmit).toHaveBeenCalledWith(expect.objectContaining({
+                    name: 'John Doe',
+                    age: 30
+                }), expect.anything());
+            });
+        }));
+        it('handles form submission with errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                {
+                    key: 'name',
+                    label: 'Name',
+                    type: 'text',
+                    validation: akival.string().required('Name is required')
+                }
+            ];
+            const onSubmit = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: onSubmit }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            yield waitFor(() => {
+                expect(screen.getByText('Name is required')).toBeInTheDocument();
+                expect(onSubmit).not.toHaveBeenCalled();
+            });
+        }));
+        it('handles form with initial values', () => __awaiter(void 0, void 0, void 0, function* () {
+            const initialValues = { name: 'John Doe', age: 30 };
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: mockOnSubmit, initialValues: initialValues }));
+            }));
+            yield waitFor(() => {
+                expect(screen.getByLabelText('Name')).toHaveValue('John Doe');
+                expect(screen.getByLabelText('Age')).toHaveValue('30');
+            });
+        }));
+        it('handles form with custom layout', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: mockOnSubmit, layout: "vertical" }));
+            }));
+            const form = screen.getByTestId('akiform-builder');
+            expect(form).toHaveClass('akinon-form-vertical');
+        }));
+        it('renders custom field correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const CustomComponent = ({ field }) => (React.createElement("div", { "data-testid": "custom-field" }, field.label));
+            const fields = [
+                {
+                    key: 'customField',
+                    label: 'Custom Field',
+                    type: 'custom',
+                    help: 'Help text',
+                    labelDescription: 'Label description text',
+                    render: ({ field }) => (React.createElement(CustomComponent, { field: field }))
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            expect(screen.getByTestId('custom-field')).toHaveTextContent('Custom Field');
+            expect(screen.getByText('Help text')).toBeInTheDocument();
+            expect(screen.getByText('Label description text')).toBeInTheDocument();
+        }));
+        it('cleans up throttle timeout on unmount', () => __awaiter(void 0, void 0, void 0, function* () {
+            vi.useFakeTimers();
+            const { unmount } = render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: mockOnSubmit, onValueChange: mockOnValueChange }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Name'), {
+                    target: { value: 'John Doe' }
+                });
+            }));
+            unmount();
+            // Advance timers and ensure onValueChange is not called
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                vi.advanceTimersByTime(THROTTLE_DELAY + 100);
+            }));
+            expect(mockOnValueChange).not.toHaveBeenCalled();
+            vi.useRealTimers();
+        }));
+        it('handles custom field with undefined render prop', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                {
+                    key: 'customField',
+                    label: 'Custom Field',
+                    type: 'custom',
+                    render: undefined
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            // The custom field should not be rendered, but the form should not crash
+            expect(screen.queryByLabelText('Custom Field')).not.toBeInTheDocument();
+            // The form should still be rendered
+            expect(screen.getByTestId('akiform-builder')).toBeInTheDocument();
+        }));
+        it('renders custom submit and reset button props', () => __awaiter(void 0, void 0, void 0, function* () {
+            const submitButtonProps = {
+                className: 'custom-submit-btn',
+                children: 'submit button'
+            };
+            const resetButtonProps = {
+                className: 'custom-reset-btn',
+                children: 'reset button'
+            };
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: mockOnSubmit, showResetButton: true, onReset: mockOnReset, submitButtonProps: submitButtonProps, resetButtonProps: resetButtonProps }));
+            }));
+            const submitButton = screen
+                .getByText(submitButtonProps.children)
+                .closest('button');
+            const resetButton = screen
+                .getByText(resetButtonProps.children)
+                .closest('button');
+            expect(submitButton).toBeInTheDocument();
+            expect(resetButton).toBeInTheDocument();
+            expect(submitButton).toHaveClass(submitButtonProps.className);
+            expect(resetButton).toHaveClass(resetButtonProps.className);
+            yield userEvent.click(resetButton);
+            expect(mockOnReset).toHaveBeenCalled();
+            yield userEvent.click(submitButton);
+            expect(mockOnSubmit).toHaveBeenCalled();
+        }));
+    });
+    describe('AkiformBuilder in controlled mode', () => {
+        it('uses provided values in controlled mode', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                { key: 'name', label: 'Name', type: 'text' },
+                { key: 'age', label: 'Age', type: 'number' }
+            ];
+            const controlledValues = { name: 'John Doe', age: 30 };
+            const onChangeMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn(), controlled: true, values: controlledValues, onValueChange: onChangeMock }));
+            }));
+            expect(screen.getByLabelText('Name')).toHaveValue('John Doe');
+            expect(screen.getByLabelText('Age')).toHaveValue('30');
+        }));
+        it('calls onValueChange when form values change in controlled mode', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                { key: 'name', label: 'Name', type: 'text' }
+            ];
+            const onChangeMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn(), controlled: true, values: { name: '' }, onValueChange: onChangeMock }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Name'), {
+                    target: { value: 'Jane Doe' }
+                });
+            }));
+            yield waitFor(() => {
+                expect(onChangeMock).toHaveBeenCalledWith(expect.objectContaining({ name: 'Jane Doe' }));
+            });
+        }));
+        it('calls onValueChange immediately in controlled mode', () => __awaiter(void 0, void 0, void 0, function* () {
+            const onValueChangeMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: mockOnSubmit, controlled: true, values: { name: 'John Doe', age: 30 }, onValueChange: onValueChangeMock }));
+            }));
+            expect(onValueChangeMock).toHaveBeenCalledWith(expect.objectContaining({ name: 'John Doe', age: 30 }));
+        }));
+        it('handles conditional rendering and disabling of fields', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                { key: 'showField', label: 'Show Field', type: 'checkbox' },
+                {
+                    key: 'conditionalField',
+                    label: 'Conditional Field',
+                    type: 'text',
+                    config: { visible: values => values.showField }
+                },
+                { key: 'enableField', label: 'Enable Field', type: 'checkbox' },
+                {
+                    key: 'disableableField',
+                    label: 'Disableable Field',
+                    type: 'text',
+                    config: { disabled: values => !values.enableField }
+                }
+            ];
+            const onValueChangeMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn(), controlled: true, values: { showField: false, enableField: false }, onValueChange: onValueChangeMock }));
+            }));
+            expect(screen.queryByLabelText('Conditional Field')).not.toBeInTheDocument();
+            expect(screen.getByLabelText('Disableable Field')).toBeDisabled();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.click(screen.getByLabelText('Show Field'));
+                fireEvent.click(screen.getByLabelText('Enable Field'));
+            }));
+            expect(screen.getByLabelText('Conditional Field')).toBeInTheDocument();
+            expect(screen.getByLabelText('Disableable Field')).not.toBeDisabled();
+            expect(onValueChangeMock).toHaveBeenCalledWith(expect.objectContaining({
+                showField: true,
+                enableField: true
+            }));
+        }));
+    });
+    describe('FieldArrayComponent', () => {
+        it('renders field array with initial values', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                {
+                    key: 'items',
+                    label: 'Items',
+                    type: 'fieldArray',
+                    fields: [
+                        { key: 'name', label: 'Item Name', type: 'text' },
+                        { key: 'quantity', label: 'Quantity', type: 'number' }
+                    ]
+                }
+            ];
+            const initialValues = {
+                items: [
+                    { name: 'Item 1', quantity: 1 },
+                    { name: 'Item 2', quantity: 2 }
+                ]
+            };
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn(), initialValues: initialValues }));
+            }));
+            yield expandCollapsable();
+            expect(screen.getAllByLabelText('Item Name')).toHaveLength(2);
+            expect(screen.getAllByLabelText('Quantity')).toHaveLength(2);
+        }));
+        it('adds and removes field array items', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const fields = [
+                {
+                    key: 'items',
+                    label: 'Items',
+                    type: 'fieldArray',
+                    fields: [{ key: 'name', label: 'Item Name', type: 'text' }]
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            // Add an item
+            yield user.click(screen.getByTestId('items-add-button'));
+            yield expandCollapsable();
+            expect(screen.getByLabelText('Item Name')).toBeInTheDocument();
+            // Add another item
+            yield user.click(screen.getByLabelText('Add Items'));
+            yield expandCollapsable();
+            expect(screen.getAllByLabelText('Item Name')).toHaveLength(2);
+            // Remove an item
+            yield user.click(screen.getAllByLabelText('Remove Items')[0]);
+            yield expandCollapsable();
+            expect(screen.getAllByLabelText('Item Name')).toHaveLength(1);
+        }));
+        it('handles field array with conditional fields', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const fields = [
+                {
+                    key: 'items',
+                    label: 'Items',
+                    type: 'fieldArray',
+                    fields: [
+                        { key: 'name', label: 'Item Name', type: 'text' },
+                        {
+                            key: 'description',
+                            label: 'Description',
+                            type: 'text',
+                            config: {
+                                visible: values => values.name && values.name.length > 5
+                            }
+                        }
+                    ]
+                }
+            ];
+            const { rerender } = render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            yield expandCollapsable();
+            // Add an item
+            yield user.click(screen.getByLabelText('Add Items'));
+            yield expandCollapsable();
+            // Description should not be visible initially
+            expect(screen.queryByLabelText('Description')).not.toBeInTheDocument();
+            // Enter a name longer than 5 characters
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByLabelText('Item Name'), {
+                    target: { value: 'Long Name' }
+                });
+            }));
+            // Force a re-render to trigger the conditional rendering
+            rerender(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            // Description should now be visible
+            yield waitFor(() => {
+                expect(screen.getByLabelText('Description')).toBeInTheDocument();
+            });
+        }));
+    });
+    describe('Edge cases and uncovered scenarios', () => {
+        it('handles field array with no fields', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                {
+                    key: 'emptyFieldArray',
+                    label: 'Empty Field Array',
+                    type: 'fieldArray',
+                    fields: []
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            // The field array should be rendered with an "Add" button
+            expect(screen.getByTestId('emptyFieldArray-add-button')).toBeInTheDocument();
+        }));
+        it('handles form submission with field array', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const fields = [
+                {
+                    key: 'items',
+                    label: 'Items',
+                    type: 'fieldArray',
+                    fields: [
+                        { key: 'name', label: 'Item Name', type: 'text' },
+                        { key: 'quantity', label: 'Quantity', type: 'number' }
+                    ]
+                }
+            ];
+            const onSubmitMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: onSubmitMock }));
+            }));
+            // Add two items
+            yield user.click(screen.getByTestId('items-add-button'));
+            yield user.click(screen.getByLabelText('Add Items'));
+            yield expandCollapsable();
+            // Fill in the fields
+            const itemNames = screen.getAllByLabelText('Item Name');
+            const quantities = screen.getAllByLabelText('Quantity');
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(itemNames[0], { target: { value: 'Item 1' } });
+                fireEvent.change(quantities[0], { target: { value: '5' } });
+                fireEvent.change(itemNames[1], { target: { value: 'Item 2' } });
+                fireEvent.change(quantities[1], { target: { value: '10' } });
+            }));
+            // Submit the form
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            yield waitFor(() => {
+                expect(onSubmitMock).toHaveBeenCalledWith(expect.objectContaining({
+                    items: [
+                        { name: 'Item 1', quantity: 5 },
+                        { name: 'Item 2', quantity: 10 }
+                    ]
+                }), expect.anything());
+            });
+        }));
+        it('handles form with all field types', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                { key: 'text', label: 'Text', type: 'text' },
+                { key: 'number', label: 'Number', type: 'number' },
+                {
+                    key: 'select',
+                    label: 'Select',
+                    type: 'select',
+                    options: [{ value: 'option1', label: 'Option 1' }]
+                },
+                { key: 'checkbox', label: 'Checkbox', type: 'checkbox' },
+                { key: 'date', label: 'Date', type: 'date' },
+                { key: 'textarea', label: 'Textarea', type: 'textarea' },
+                {
+                    key: 'fieldArray',
+                    label: 'Field Array',
+                    type: 'fieldArray',
+                    fields: [{ key: 'subfield', label: 'Subfield', type: 'text' }]
+                },
+                {
+                    key: 'custom',
+                    label: 'Custom',
+                    type: 'custom',
+                    render: () => React.createElement("div", { "data-testid": "custom-field" }, "Custom Field")
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            expect(screen.getByLabelText('Text')).toBeInTheDocument();
+            expect(screen.getByLabelText('Number')).toBeInTheDocument();
+            expect(screen.getByLabelText('Select')).toBeInTheDocument();
+            expect(screen.getByLabelText('Checkbox')).toBeInTheDocument();
+            expect(screen.getByLabelText('Date')).toBeInTheDocument();
+            expect(screen.getByLabelText('Textarea')).toBeInTheDocument();
+            expect(screen.getByTestId('fieldArray-add-button')).toBeInTheDocument(); // For field array
+            expect(screen.getByTestId('custom-field')).toBeInTheDocument();
+        }));
+        it('handles form with inline layout', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: vi.fn(), layout: "inline" }));
+            }));
+            const form = screen.getByTestId('akiform-builder');
+            expect(form).toHaveClass('akinon-form-inline');
+        }));
+        it('handles form reset with custom reset handler', () => __awaiter(void 0, void 0, void 0, function* () {
+            const onResetMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: defaultFields, onSubmit: vi.fn(), onReset: onResetMock, showResetButton: true }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.click(screen.getByText('RESET'));
+            }));
+            expect(onResetMock).toHaveBeenCalled();
+        }));
+    });
+    describe('AkiformBuilder with FieldBuilder', () => {
+        it('renders form fields created with FieldBuilder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                field()
+                    .key('name')
+                    .label('Name')
+                    .type('text')
+                    .placeholder('Enter your name')
+                    .help('Help text')
+                    .labelDescription('Label description text')
+                    .build(),
+                field()
+                    .key('age')
+                    .label('Age')
+                    .type('number')
+                    .placeholder('Enter your age')
+                    .build(),
+                field()
+                    .key('country')
+                    .label('Country')
+                    .type('select')
+                    .options([
+                    { value: 'us', label: 'United States' },
+                    { value: 'ca', label: 'Canada' }
+                ])
+                    .build(),
+                field()
+                    .key('subscribe')
+                    .label('Subscribe to newsletter')
+                    .type('checkbox')
+                    .build(),
+                field().key('birthdate').label('Birth Date').type('date').build(),
+                field().key('description').label('Description').type('textarea').build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            expect(screen.getByText('Name')).toBeInTheDocument();
+            expect(screen.getByText('Label description text')).toBeInTheDocument();
+            expect(screen.getByText('Help text')).toBeInTheDocument();
+            expect(screen.getByLabelText('Age')).toBeInTheDocument();
+            expect(screen.getByLabelText('Country')).toBeInTheDocument();
+            expect(screen.getByLabelText('Subscribe to newsletter')).toBeInTheDocument();
+            expect(screen.getByLabelText('Birth Date')).toBeInTheDocument();
+            expect(screen.getByLabelText('Description')).toBeInTheDocument();
+        }));
+        it('handles form submission with fields created by FieldBuilder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                field()
+                    .key('name')
+                    .label('Name')
+                    .type('text')
+                    .validation(akival.string().required('Name is required'))
+                    .build(),
+                field()
+                    .key('age')
+                    .label('Age')
+                    .type('number')
+                    .validation(akival.number().min(18, 'Must be at least 18'))
+                    .build()
+            ];
+            const onSubmitMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: onSubmitMock }));
+            }));
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByRole('textbox', { name: /name/i }), {
+                    target: { value: 'John Doe' }
+                });
+                fireEvent.change(screen.getByRole('spinbutton', { name: /age/i }), {
+                    target: { value: '25' }
+                });
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            yield waitFor(() => {
+                expect(onSubmitMock).toHaveBeenCalledWith(expect.objectContaining({
+                    name: 'John Doe',
+                    age: 25
+                }), expect.anything());
+            });
+        }));
+        it('handles form with custom field created by FieldBuilder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const CustomComponent = ({ field }) => (React.createElement("div", { "data-testid": "custom-field" }, field.label));
+            const fields = [
+                field()
+                    .key('customField')
+                    .label('Custom Field')
+                    .type('custom')
+                    .help('Help text')
+                    .labelDescription('Label description text')
+                    .render(({ field }) => React.createElement(CustomComponent, { field: field }))
+                    .build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            expect(screen.getByTestId('custom-field')).toHaveTextContent('Custom Field');
+            expect(screen.getByText('Help text')).toBeInTheDocument();
+            expect(screen.getByText('Label description text')).toBeInTheDocument();
+        }));
+        it('handles form with field array created by FieldBuilder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const fields = [
+                field()
+                    .key('addresses')
+                    .label('Addresses')
+                    .type('fieldArray')
+                    .fields([
+                    field()
+                        .key('street')
+                        .label('Street')
+                        .type('text')
+                        .help('Help text')
+                        .labelDescription('Label description text')
+                        .placeholder('Enter your street')
+                        .build(),
+                    field().key('city').label('City').type('text').build()
+                ])
+                    .build()
+            ];
+            const onSubmitMock = vi.fn();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: onSubmitMock }));
+            }));
+            // Add an address
+            yield user.click(screen.getByTestId('addresses-add-button'));
+            yield expandCollapsable();
+            //Check rendered fields
+            expect(screen.getByText('Street')).toBeInTheDocument();
+            expect(screen.getByText('Help text')).toBeInTheDocument();
+            expect(screen.getByText('Label description text')).toBeInTheDocument();
+            expect(screen.getByLabelText('City')).toBeInTheDocument();
+            // Fill in the fields
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.change(screen.getByPlaceholderText('Enter your street'), {
+                    target: { value: '123 Main St' }
+                });
+                fireEvent.change(screen.getByLabelText('City'), {
+                    target: { value: 'Anytown' }
+                });
+            }));
+            // Submit the form
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.submit(screen.getByTestId('akiform-builder'));
+            }));
+            yield waitFor(() => {
+                expect(onSubmitMock).toHaveBeenCalledWith(expect.objectContaining({
+                    addresses: [{ street: '123 Main St', city: 'Anytown' }]
+                }), expect.anything());
+            });
+        }));
+        it('handles conditional rendering with FieldBuilder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                field().key('showField').label('Show Field').type('checkbox').build(),
+                field()
+                    .key('conditionalField')
+                    .label('Conditional Field')
+                    .type('text')
+                    .config({ visible: (values) => values.showField })
+                    .build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            expect(screen.queryByLabelText('Conditional Field')).not.toBeInTheDocument();
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.click(screen.getByLabelText('Show Field'));
+            }));
+            expect(screen.getByLabelText('Conditional Field')).toBeInTheDocument();
+        }));
+        it('handles disabled fields with FieldBuilder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                field()
+                    .key('disabledField')
+                    .label('Disabled Field')
+                    .type('text')
+                    .config({ disabled: true })
+                    .build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            expect(screen.getByLabelText('Disabled Field')).toBeDisabled();
+        }));
+    });
+    describe('Accessibility features', () => {
+        it('renders form with proper ARIA attributes', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                {
+                    key: 'name',
+                    label: 'Name',
+                    type: 'text',
+                    validation: akival.string().required()
+                },
+                { key: 'age', label: 'Age', type: 'number' }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            const form = screen.getByRole('form');
+            expect(form).toHaveAttribute('aria-label', 'Form');
+            const nameInput = screen.getByRole('textbox', { name: /name/i });
+            expect(nameInput).toHaveAttribute('aria-required', 'true');
+            expect(nameInput).toHaveAttribute('aria-invalid', 'false');
+            const ageInput = screen.getByRole('spinbutton', { name: /age/i });
+            expect(ageInput).toHaveAttribute('aria-required', 'false');
+            expect(ageInput).toHaveAttribute('aria-invalid', 'false');
+        }));
+        it('updates aria-invalid attribute when form is submitted with errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                {
+                    key: 'name',
+                    label: 'Name',
+                    type: 'text',
+                    validation: akival.string().required('Name is required')
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            const nameInput = screen.getByRole('textbox', { name: /name/i });
+            expect(nameInput).toHaveAttribute('aria-invalid', 'false');
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.submit(screen.getByRole('form'));
+            }));
+            yield waitFor(() => {
+                expect(nameInput).toHaveAttribute('aria-invalid', 'true');
+                expect(screen.getByText('Name is required')).toBeInTheDocument();
+            });
+        }));
+        it('renders field array with proper ARIA attributes', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const fields = [
+                {
+                    key: 'addresses',
+                    label: 'Addresses',
+                    type: 'fieldArray',
+                    fields: [
+                        { key: 'street', label: 'Street', type: 'text' },
+                        { key: 'city', label: 'City', type: 'text' }
+                    ]
+                }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            yield user.click(screen.getByTestId('addresses-add-button'));
+            yield expandCollapsable();
+            const fieldArrayGroup = screen.getByRole('group', { name: 'Addresses' });
+            expect(fieldArrayGroup).toBeInTheDocument();
+            const addButton = screen.getByLabelText('Add Addresses');
+            expect(addButton).toBeInTheDocument();
+            yield user.click(addButton);
+            yield expandCollapsable();
+            const removeButton = screen.getAllByLabelText('Remove Addresses')[1];
+            expect(removeButton).toBeInTheDocument();
+        }));
+        it('supports keyboard navigation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const user = userEvent.setup();
+            const fields = [
+                { key: 'name', label: 'Name', type: 'text' },
+                { key: 'age', label: 'Age', type: 'number' }
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn(), showResetButton: true }));
+            }));
+            const nameInput = screen.getByLabelText('Name');
+            const ageInput = screen.getByLabelText('Age');
+            const submitButton = screen.getByRole('button', { name: 'SUBMIT' });
+            const resetButton = screen.getByRole('button', { name: 'RESET' });
+            yield user.tab();
+            expect(document.activeElement).toBe(nameInput);
+            yield user.tab();
+            expect(document.activeElement).toBe(ageInput);
+            yield user.tab();
+            expect(document.activeElement).toBe(submitButton);
+            yield user.tab();
+            expect(document.activeElement).toBe(resetButton);
+        }));
+    });
+    describe('AkiformBuilder with sections', () => {
+        it('renders form with sections', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                field()
+                    .key('personalInfo')
+                    .label('Personal Information')
+                    .type('section')
+                    .fields([
+                    field()
+                        .key('name')
+                        .label('Name')
+                        .type('text')
+                        .help('Help text')
+                        .labelDescription('Label description text')
+                        .build(),
+                    field().key('age').label('Age').type('number').build()
+                ])
+                    .collapsible(true)
+                    .defaultExpanded(true)
+                    .build(),
+                field()
+                    .key('contactInfo')
+                    .label('Contact Information')
+                    .type('section')
+                    .collapsible(true)
+                    .defaultExpanded(false)
+                    .fields([
+                    field().key('email').label('Email').type('text').build(),
+                    field().key('phone').label('Phone').type('text').build()
+                ])
+                    .build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            expect(screen.getByText('Personal Information')).toBeInTheDocument();
+            expect(screen.getByText('Contact Information')).toBeInTheDocument();
+            expect(screen.getByText('Name')).toBeInTheDocument();
+            expect(screen.getByText('Help text')).toBeInTheDocument();
+            expect(screen.getByText('Label description text')).toBeInTheDocument();
+            expect(screen.getByLabelText('Age')).toBeInTheDocument();
+            // Check if the first section is expanded by default
+            expect(screen.getByText('Name').closest('label')).toBeVisible();
+            // Check if the second section is collapsed by default
+            expect(screen.queryByLabelText('Email')).not.toBeInTheDocument();
+            // Expand the second section
+            const contactInfoSection = screen.getByText('Contact Information');
+            yield userEvent.click(contactInfoSection);
+            // Wait for the section to expand
+            yield waitFor(() => {
+                expect(screen.getByLabelText('Email')).toBeInTheDocument();
+            });
+            // Check if the Email field is now visible
+            // const emailInput = screen.getByLabelText('Email');
+            // expect(emailInput).toBeVisible();
+            // Additional debug information
+            // if (!emailInput.isConnected) {
+            //   console.error('Email input is not connected to the DOM');
+            // }
+            // console.log(
+            //   'Email input visibility:',
+            //   window.getComputedStyle(emailInput).display
+            // );
+        }));
+        it('handles form submission with sections', () => __awaiter(void 0, void 0, void 0, function* () {
+            const onSubmitMock = vi.fn();
+            const fields = [
+                field()
+                    .key('personalInfo')
+                    .label('Personal Information')
+                    .type('section')
+                    .fields([
+                    field().key('name').label('Name').type('text').build(),
+                    field().key('age').label('Age').type('number').build()
+                ])
+                    .build(),
+                field()
+                    .key('contactInfo')
+                    .label('Contact Information')
+                    .type('section')
+                    .fields([field().key('email').label('Email').type('text').build()])
+                    .build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: onSubmitMock }));
+            }));
+            // Expand both sections
+            yield userEvent.click(screen.getByText('Personal Information'));
+            yield userEvent.click(screen.getByText('Contact Information'));
+            // Fill in the form
+            yield userEvent.type(screen.getByLabelText('Name'), 'John Doe', {
+                delay: 1
+            });
+            yield userEvent.type(screen.getByLabelText('Age'), '30', { delay: 1 });
+            yield userEvent.type(screen.getByLabelText('Email'), 'john@example.com', {
+                delay: 1
+            });
+            // Wait for submit button to become interactable
+            const submitButton = screen.getByRole('button', { name: /submit/i });
+            yield waitFor(() => {
+                expect(submitButton).toBeEnabled();
+            });
+            // Submit the form
+            yield userEvent.click(submitButton);
+            // Validate submission
+            expect(onSubmitMock).toHaveBeenCalledWith({
+                name: 'John Doe',
+                age: 30,
+                email: 'john@example.com'
+            }, expect.anything());
+        }));
+        it('handles conditional rendering within sections', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                field()
+                    .key('personalInfo')
+                    .label('Personal Information')
+                    .type('section')
+                    .fields([
+                    field().key('name').label('Name').type('text').build(),
+                    field().key('showAge').label('Show Age').type('checkbox').build(),
+                    field()
+                        .key('age')
+                        .label('Age')
+                        .type('number')
+                        .config({ visible: (values) => values.showAge })
+                        .build()
+                ])
+                    .defaultExpanded(true)
+                    .build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            expect(screen.getByLabelText('Name')).toBeInTheDocument();
+            expect(screen.getByLabelText('Show Age')).toBeInTheDocument();
+            expect(screen.queryByLabelText('Age')).not.toBeInTheDocument();
+            yield userEvent.click(screen.getByLabelText('Show Age'));
+            expect(yield screen.findByLabelText('Age')).toBeInTheDocument();
+        }));
+    });
+    describe('AkiformBuilder with tooltip', () => {
+        it('renders form field with tooltip as TooltipProps', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                field()
+                    .key('name')
+                    .label('Name')
+                    .type('text')
+                    .tooltip({ title: 'Enter your full name', defaultOpen: true })
+                    .build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            const tooltipTrigger = screen.getByLabelText('Name');
+            expect(tooltipTrigger).toBeInTheDocument();
+            // Simulate hovering over the field to show the tooltip
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.mouseEnter(tooltipTrigger);
+            }));
+            // Wait for the tooltip to appear
+            yield waitFor(() => {
+                expect(screen.getByText('Enter your full name')).toBeInTheDocument();
+            });
+        }));
+        it('renders form field with tooltip as string', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fields = [
+                field()
+                    .key('email')
+                    .label('Email')
+                    .type('text')
+                    .tooltip({ title: 'Enter your full name', defaultOpen: true })
+                    .build()
+            ];
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                render(React.createElement(AkiformBuilder, { fields: fields, onSubmit: vi.fn() }));
+            }));
+            const tooltipTrigger = screen.getByLabelText('Email');
+            expect(tooltipTrigger).toBeInTheDocument();
+            // Simulate hovering over the field to show the tooltip
+            yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+                fireEvent.mouseEnter(tooltipTrigger);
+            }));
+            // Wait for the tooltip to appear
+            yield waitFor(() => {
+                expect(screen.getByText('Enter your full name')).toBeInTheDocument();
+            });
+        }));
+    });
+});