@digigov/form 2.0.0-8de46296 → 2.0.0-96651090

package/FieldArray/FormDialog/index.js

@@ -0,0 +1,199 @@
+import react, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useFieldArray } from "react-hook-form";
+import { ArrayDisplay } from "./ArrayDisplay/index.js";
+import { ArrayEditModal } from "./ArrayEditModal.js";
+import { useFormContext } from "../../FormContext.js";
+import { useModal } from "@digigov/ui/app/Modal/index.js";
+import { Button } from "@digigov/ui/form/Button/index.js";
+import { Hint } from "@digigov/ui/typography/Hint/index.js";
+const FormDialog = /*#__PURE__*/ react.forwardRef(({ name: fieldArrayName, control, error, getValues, Field, sortable, ...customField }, ref)=>{
+    const [isAppending, setIsAppending] = useState(false);
+    const [editingIndex, setEditingIndex] = useState(0);
+    const { fields, append, remove, update, move } = useFieldArray({
+        control,
+        name: fieldArrayName
+    });
+    const { open, close, registerModal } = useModal();
+    const currentLength = fields.length;
+    const arrayItemName = isAppending ? `${fieldArrayName}.${currentLength}` : `${fieldArrayName}.${editingIndex}`;
+    useEffect(()=>{
+        if (isAppending) open(`modal-${fieldArrayName}`);
+    }, [
+        isAppending,
+        fieldArrayName,
+        open
+    ]);
+    const fieldArrayValues = getValues(fieldArrayName);
+    const ofField = useMemo(()=>({
+            ...customField.extra?.of,
+            name: arrayItemName
+        }), [
+        arrayItemName,
+        customField.extra?.of
+    ]);
+    if ('object' !== ofField.type) {
+        ofField.name = ofField.key ?? fieldArrayName;
+        ofField.key = ofField.key ?? fieldArrayName;
+    }
+    const defaultValue = useMemo(()=>{
+        if (isAppending) if ('object' === ofField.type) return ofField.defaultValue;
+        else return {
+            [ofField.name]: ofField.defaultValue
+        };
+        if ('object' === ofField.type) return getValues(ofField.name);
+        return {
+            [ofField.name]: fieldArrayValues?.[editingIndex]
+        };
+    }, [
+        editingIndex,
+        fieldArrayValues,
+        getValues,
+        isAppending,
+        ofField.defaultValue,
+        ofField.name,
+        ofField.type
+    ]);
+    const hasCommitedValues = fields.length > 0 || !!fieldArrayValues?.length;
+    const title = useMemo(()=>{
+        if (!customField.extra?.label.object.title) return null;
+        let title = customField.extra.label.object.title;
+        if (customField.extra.label.object.titleNumbering) title += ` ${currentLength + 1}`;
+        return title;
+    }, [
+        currentLength,
+        customField.extra?.label.object.title,
+        customField.extra?.label.object.titleNumbering
+    ]);
+    const focusReturnRef = useRef(null);
+    const closeModal = useCallback(()=>{
+        close();
+        if (focusReturnRef.current) {
+            focusReturnRef.current.focus();
+            focusReturnRef.current = null;
+        }
+    }, [
+        close
+    ]);
+    const { clearErrors, setError } = useFormContext();
+    const handleEditOrAppend = useCallback((data)=>{
+        if (isAppending) {
+            setIsAppending(false);
+            if ('object' === ofField.type) append(data);
+            else if (data) {
+                const submittedValue = data[ofField.key ?? fieldArrayName];
+                if (submittedValue) append(submittedValue);
+            }
+        } else {
+            clearErrors(`${fieldArrayName}.${editingIndex}`);
+            if ('object' === ofField.type) update(editingIndex, data);
+            else if (data) {
+                const submittedValue = data[ofField.key ?? fieldArrayName];
+                if (submittedValue) update(editingIndex, submittedValue);
+            }
+        }
+        closeModal();
+    }, [
+        clearErrors,
+        append,
+        closeModal,
+        editingIndex,
+        fieldArrayName,
+        isAppending,
+        ofField.key,
+        ofField.type,
+        update
+    ]);
+    const handleCancel = useCallback(()=>{
+        if (isAppending) setIsAppending(false);
+        closeModal();
+    }, [
+        closeModal,
+        isAppending
+    ]);
+    const handleOpenEditModal = useCallback((index)=>{
+        if (document.activeElement instanceof HTMLElement) focusReturnRef.current = document.activeElement;
+        setEditingIndex(index);
+        open(`modal-${fieldArrayName}`);
+    }, [
+        fieldArrayName,
+        open
+    ]);
+    const handleAddClick = useCallback((ev)=>{
+        ev.preventDefault();
+        if (document.activeElement instanceof HTMLElement) focusReturnRef.current = document.activeElement;
+        setIsAppending(true);
+    }, []);
+    const handleRemove = useCallback((index)=>{
+        remove(index);
+        if (error) {
+            for(let i = index; i < fields.length - 1; i++){
+                clearErrors(`${fieldArrayName}.${i}`);
+                if (error[i + 1]) Object.keys(error[i + 1]).forEach((fieldName)=>{
+                    setError(`${fieldArrayName}.${i}.${fieldName}`, error[i + 1][fieldName]);
+                });
+            }
+            clearErrors(`${fieldArrayName}.${fields.length - 1}`);
+        }
+    }, [
+        clearErrors,
+        error,
+        fieldArrayName,
+        fields.length,
+        remove,
+        setError
+    ]);
+    const handleMove = useCallback((from, to)=>{
+        if (error && (error[from] || error[to])) {
+            const temp = error[from];
+            error[from] = error[to];
+            error[to] = temp;
+        }
+        move(from, to);
+    }, [
+        error,
+        move
+    ]);
+    return /*#__PURE__*/ react.createElement(react.Fragment, null, !hasCommitedValues && /*#__PURE__*/ react.createElement(Hint, customField.extra?.label.object?.nothing_added_props, customField.extra?.label.object?.nothing_added), /*#__PURE__*/ react.createElement(ArrayEditModal, {
+        editOrAppend: handleEditOrAppend,
+        cancel: handleCancel,
+        type: isAppending ? 'append' : 'edit',
+        appendLabel: customField.extra?.label.object.append.label,
+        appendProps: customField.extra?.label.object.append.props,
+        editLabel: customField.extra?.label.object.edit.label,
+        editProps: customField.extra?.label.object.edit.props,
+        cancelLabel: customField.extra?.label.object.cancel.label,
+        cancelProps: customField.extra?.label.object.cancel.props,
+        ofField: ofField,
+        title: title,
+        hint: customField.label?.secondary,
+        name: fieldArrayName,
+        defaultValue: defaultValue || void 0,
+        Field: Field,
+        error: error?.[editingIndex] ? error[editingIndex] : void 0,
+        ...registerModal(`modal-${fieldArrayName}`)
+    }), hasCommitedValues && /*#__PURE__*/ react.createElement(ArrayDisplay, {
+        fieldArrayName: fieldArrayName,
+        fieldArrayValues: fieldArrayValues,
+        ofField: ofField,
+        customField: customField,
+        onEdit: handleOpenEditModal,
+        onRemove: handleRemove,
+        move: handleMove,
+        sortable: sortable,
+        error: error
+    }), customField.extra?.editVariant !== 'display' && !customField.extra?.noAdd && /*#__PURE__*/ react.createElement("div", {
+        className: customField.extra?.label.object?.addButtonVariant === 'link' ? 'my-2 px-2 py-2 bg-gray-200 border-t border-b border-gray-400' : '',
+        ...customField?.extra?.label.object?.buttonGroup
+    }, /*#__PURE__*/ react.createElement(Button, {
+        ref: ref,
+        type: "button",
+        name: `${fieldArrayName}-add-object`,
+        color: "secondary",
+        variant: customField.extra?.label.object?.addButtonVariant,
+        onClick: handleAddClick,
+        disabled: customField?.editable === false || customField.extra?.editVariant === 'noinput' || fields.length >= (customField.extra?.max ?? Number.MAX_VALUE)
+    }, customField.extra?.label.object?.add)));
+});
+FormDialog.displayName = 'FormDialog';
+const FieldArray_FormDialog = FormDialog;
+export { FormDialog, FieldArray_FormDialog as default };

package/FieldArray/index.d.ts

@@ -1,11 +1,20 @@
 import React from 'react';
-import { ErrorOption, UseFormReturn } from 'react-hook-form';
-import { FieldProps } from '@digigov/form/Field/types';
+import type { ErrorOption, UseFormReturn } from 'react-hook-form';
+import type { FieldProps } from '../Field/types.js';
+import type { registerFieldFocus } from '../types.js';
 export interface FieldArrayProps extends FieldProps {
     control: UseFormReturn['control'];
+    trigger: UseFormReturn['trigger'];
     register: UseFormReturn['register'];
+    clearErrors: UseFormReturn['clearErrors'];
     formState: UseFormReturn['formState'];
     error?: ErrorOption;
+    getValues: UseFormReturn['getValues'];
+    setValue: UseFormReturn['setValue'];
+    reset: UseFormReturn['reset'];
+    resetField?: UseFormReturn['resetField'];
+    Field: React.FC<FieldProps>;
+    registerFieldFocus: registerFieldFocus;
 }
 export declare const FieldArray: React.FC<FieldArrayProps>;
 export default FieldArray;

package/FieldArray/index.js

@@ -1,61 +1,66 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-var _excluded = ["name", "register", "control", "formState", "error", "layout", "label"];
-import React from 'react';
-import { useFieldArray } from 'react-hook-form';
-import FieldContainer from '@digigov/form/Field/FieldBaseContainer';
-import FieldObject from '@digigov/form/FieldObject';
-import { FieldsetLabel } from '@digigov/form/Fieldset';
-import Fieldset from '@digigov/react-core/Fieldset';
-import { Button, Card, Hint } from '@digigov/ui';
-export var FieldArray = function FieldArray(_ref) {
-  var _customField$extra, _customField$extra$la, _customField$extra4, _customField$extra4$l;
-  var name = _ref.name,
-    register = _ref.register,
-    control = _ref.control,
-    formState = _ref.formState,
-    error = _ref.error,
-    layout = _ref.layout,
-    label = _ref.label,
-    customField = _objectWithoutProperties(_ref, _excluded);
-  var _useFieldArray = useFieldArray({
-      control: control,
-      name: name
-    }),
-    fields = _useFieldArray.fields,
-    append = _useFieldArray.append,
-    remove = _useFieldArray.remove;
-  return /*#__PURE__*/React.createElement(FieldContainer, {
-    label: label,
-    layout: layout,
-    error: formState.isSubmitted && !formState.isSubmitting && error !== null && error !== void 0 && error.message && error ? error : undefined,
-    wrapper: "fieldset",
-    name: name
-  }, fields.length === 0 && /*#__PURE__*/React.createElement(Hint, null, (_customField$extra = customField.extra) === null || _customField$extra === void 0 ? void 0 : (_customField$extra$la = _customField$extra.label.object) === null || _customField$extra$la === void 0 ? void 0 : _customField$extra$la.nothing_added), fields.map(function (field, index) {
-    var _customField$extra2, _customField$extra3;
-    return /*#__PURE__*/React.createElement(Card, {
-      variant: "border",
-      key: field.id
-    }, /*#__PURE__*/React.createElement(Fieldset, null, /*#__PURE__*/React.createElement(FieldsetLabel, null, (_customField$extra2 = customField.extra) === null || _customField$extra2 === void 0 ? void 0 : _customField$extra2.label.object.title, " ", index + 1), /*#__PURE__*/React.createElement(FieldObject, _extends({
-      name: "".concat(name, ".").concat(index),
-      error: Array.isArray(error) && error[index],
-      formState: formState,
-      register: register,
-      control: control
-    }, (_customField$extra3 = customField.extra) === null || _customField$extra3 === void 0 ? void 0 : _customField$extra3.of)), /*#__PURE__*/React.createElement(Button, {
-      type: "button",
-      color: "warning",
-      onClick: function onClick() {
-        return remove(index);
-      }
-    }, "Remove")));
-  }), /*#__PURE__*/React.createElement(Button, {
-    type: "button",
-    color: "secondary",
-    onClick: function onClick(ev) {
-      ev.preventDefault();
-      append({});
-    }
-  }, (_customField$extra4 = customField.extra) === null || _customField$extra4 === void 0 ? void 0 : (_customField$extra4$l = _customField$extra4.label.object) === null || _customField$extra4$l === void 0 ? void 0 : _customField$extra4$l.add));
+import react, { useEffect, useRef } from "react";
+import { FieldBaseContainer } from "../Field/FieldBaseContainer.js";
+import BaseFieldArray from "./BaseFieldArray.js";
+import { FormDialog } from "./FormDialog/index.js";
+const FieldArray = ({ name, trigger, register, clearErrors, control, formState, error, getValues, setValue, layout, reset, resetField, label, Field, registerFieldFocus, ...customField })=>{
+    const buttonRef = useRef(null);
+    useEffect(()=>{
+        let unregister = ()=>{};
+        if (buttonRef.current) unregister = registerFieldFocus(name, buttonRef.current);
+        return ()=>{
+            unregister(name);
+        };
+    }, [
+        name,
+        registerFieldFocus
+    ]);
+    const hasItemErrors = !!error && Object.keys(error).some((key)=>/^\d+$/.test(key));
+    useEffect(()=>{
+        if (!hasItemErrors) clearErrors(name);
+    }, [
+        clearErrors,
+        hasItemErrors,
+        name
+    ]);
+    return /*#__PURE__*/ react.createElement(FieldBaseContainer, {
+        label: label,
+        layout: layout,
+        register: register,
+        error: error?.message ? error : void 0,
+        hasError: !!error,
+        wrapper: "fieldset",
+        name: name,
+        labelSize: customField.extra?.labelSize,
+        controlled: true
+    }, customField.extra?.variant === 'dialog' ? /*#__PURE__*/ react.createElement(FormDialog, {
+        ref: buttonRef,
+        name: name,
+        trigger: trigger,
+        register: register,
+        clearErrors: clearErrors,
+        control: control,
+        formState: formState,
+        error: error,
+        getValues: getValues,
+        setValue: setValue,
+        layout: layout,
+        label: label,
+        Field: Field,
+        reset: reset,
+        resetField: resetField,
+        sortable: customField.extra.sortable,
+        ...customField
+    }) : /*#__PURE__*/ react.createElement(BaseFieldArray, {
+        ref: buttonRef,
+        name: name,
+        register: register,
+        control: control,
+        formState: formState,
+        error: error,
+        getValues: getValues,
+        Field: Field,
+        ...customField
+    }));
 };
-export default FieldArray;
+const src_FieldArray = FieldArray;
+export { FieldArray, src_FieldArray as default };

package/FieldObject/index.d.ts

@@ -1,22 +1,30 @@
 import React from 'react';
-import { ErrorOption, UseFormReturn } from 'react-hook-form';
-import { FieldProps } from '@digigov/form/Field/types';
-import { FieldSpec } from '@digigov/form/types';
+import type { ErrorOption, UseFormReturn } from 'react-hook-form';
+import type { FieldProps } from '../Field/types.js';
+import type { FieldSpec } from '../types.js';
 export interface FieldObjectProps extends Omit<FieldProps, 'key'> {
     control: UseFormReturn['control'];
     register: UseFormReturn['register'];
     reset: UseFormReturn['reset'];
+    resetField: UseFormReturn['resetField'];
     formState: UseFormReturn['formState'];
     error?: ErrorOption;
+    defaultValue?: any;
+    Field: React.FC<FieldProps>;
 }
 export declare const FieldObject: React.FC<FieldObjectProps>;
 export interface FieldObjectItemProps {
+    key: string;
     name: string;
     field: FieldSpec;
     control: UseFormReturn['control'];
     register: UseFormReturn['register'];
     reset: UseFormReturn['reset'];
+    resetField: UseFormReturn['resetField'];
     formState: UseFormReturn['formState'];
     error?: ErrorOption;
+    children?: React.ReactNode;
+    defaultValue?: undefined;
+    Field: React.FC<FieldProps>;
 }
 export default FieldObject;

package/FieldObject/index.js

@@ -1,54 +1,55 @@
-import _extends from "@babel/runtime/helpers/extends";
-import React, { useMemo } from 'react';
-import { FieldBase } from '@digigov/form/Field/FieldBase';
-import { calculateField } from '@digigov/form/Field/utils';
-import Fieldset, { FieldsetCaption } from '@digigov/form/Fieldset';
-import { FieldsetLegend } from '@digigov/react-core';
-import { useTranslation } from '@digigov/ui/i18n';
-export var FieldObject = function FieldObject(_ref) {
-  var name = _ref.name,
-    label = _ref.label,
-    extra = _ref.extra,
-    control = _ref.control,
-    register = _ref.register,
-    reset = _ref.reset,
-    formState = _ref.formState;
-  var _useTranslation = useTranslation(),
-    t = _useTranslation.t;
-  return /*#__PURE__*/React.createElement(Fieldset, null, (label === null || label === void 0 ? void 0 : label.primary) && /*#__PURE__*/React.createElement(FieldsetLegend, {
-    size: "sm"
-  }, t(label.primary)), (label === null || label === void 0 ? void 0 : label.secondary) && /*#__PURE__*/React.createElement(FieldsetCaption, null, t(label.secondary)), extra === null || extra === void 0 ? void 0 : extra.fields.map(function (field) {
-    return /*#__PURE__*/React.createElement(FieldObjectItem, {
-      key: "".concat(name, ".").concat(field.key),
-      name: "".concat(name, ".").concat(field.key),
-      control: control,
-      register: register,
-      reset: reset,
-      field: field,
-      error: formState.errors && formState.errors[field.key],
-      formState: formState
-    });
-  }));
+import react, { useMemo } from "react";
+import { FieldBase } from "../Field/FieldBase.js";
+import { resolveField } from "../Field/utils/resolveField.js";
+import { Fieldset, FieldsetCaption } from "../Fieldset/index.js";
+import { FieldsetLegend } from "@digigov/ui/form/FieldContainer/index.js";
+import { useTranslation } from "@digigov/ui/i18n/index.js";
+const FieldObject = ({ name, label, extra, control, register, reset, resetField, formState, error, defaultValue, Field })=>{
+    const { t } = useTranslation();
+    return /*#__PURE__*/ react.createElement(Fieldset, null, label?.primary && /*#__PURE__*/ react.createElement(FieldsetLegend, {
+        size: "sm",
+        marginBottom: 3
+    }, t(label.primary)), label?.secondary && /*#__PURE__*/ react.createElement(FieldsetCaption, {
+        marginBottom: 3
+    }, t(label.secondary)), extra?.fields.map((field)=>/*#__PURE__*/ react.createElement(FieldObjectItem, {
+            key: `${name ? name + '.' : ''}${field.key ? `${field.key}` : ''}`,
+            name: `${name ? name + '.' : ''}${field.key ? `${field.key}` : ''}`,
+            control: control,
+            register: register,
+            reset: reset,
+            resetField: resetField,
+            field: field,
+            error: error && error[field.key],
+            formState: formState,
+            defaultValue: defaultValue?.[field.key] || void 0,
+            Field: Field
+        })));
 };
-var FieldObjectItem = function FieldObjectItem(_ref2) {
-  var name = _ref2.name,
-    children = _ref2.children,
-    field = _ref2.field,
-    error = _ref2.error,
-    control = _ref2.control,
-    formState = _ref2.formState,
-    reset = _ref2.reset,
-    register = _ref2.register;
-  var calculatedField = useMemo(function () {
-    return calculateField(children, field);
-  }, [field]);
-  var customError = error ? error : formState === null || formState === void 0 ? void 0 : formState.errors[name];
-  return /*#__PURE__*/React.createElement(FieldBase, _extends({}, calculatedField, {
-    name: name,
-    control: control,
-    reset: reset,
-    register: register,
-    error: customError
-  }));
+const FieldObjectItem = ({ name, children, field, error, control, formState, reset, resetField, register, defaultValue, Field })=>{
+    const resolvedField = useMemo(()=>resolveField(children, field), [
+        field
+    ]);
+    if (Field) {
+        if (!field.type) field.type = 'string';
+        return /*#__PURE__*/ react.createElement(Field, {
+            ...field,
+            name: name
+        });
+    }
+    {
+        const customError = error ? error : formState?.errors[name];
+        return /*#__PURE__*/ react.createElement(FieldBase, {
+            ...resolvedField,
+            name: name,
+            Field: Field,
+            control: control,
+            reset: reset,
+            resetField: resetField,
+            register: register,
+            error: customError,
+            defaultValue: defaultValue
+        });
+    }
 };
-export default FieldObject;
+const src_FieldObject = FieldObject;
+export { FieldObject, src_FieldObject as default };

package/Fieldset/FieldsetWithContext.js

@@ -0,0 +1,27 @@
+import react, { useContext, useMemo } from "react";
+import Field from "../Field/index.js";
+import { Fieldset, FieldsetBody, FieldsetCaption, FieldsetLabel } from "./index.js";
+import { FormContext } from "../FormContext.js";
+import { useTranslation } from "@digigov/ui/i18n/index.js";
+const FieldsetWithContext = ({ name })=>{
+    const { label, body, fields } = useFieldset(name);
+    const { t } = useTranslation();
+    return useMemo(()=>/*#__PURE__*/ react.createElement(Fieldset, null, label?.primary && /*#__PURE__*/ react.createElement(FieldsetLabel, null, t(label.primary)), label?.secondary && /*#__PURE__*/ react.createElement(FieldsetCaption, null, t(label.secondary)), body && /*#__PURE__*/ react.createElement(FieldsetBody, null, body), fields.map((field)=>/*#__PURE__*/ react.createElement(Field, {
+                key: field,
+                name: field
+            }))), [
+        label?.primary,
+        label?.secondary,
+        body,
+        fields
+    ]);
+};
+const useFieldset = (name)=>{
+    const { fieldsetsMap } = useContext(FormContext);
+    if (fieldsetsMap && fieldsetsMap[name]) return useMemo(()=>fieldsetsMap[name], [
+        name
+    ]);
+    if (!fieldsetsMap) throw new Error("Fieldsets is not defined");
+    throw new Error(`No fieldset with name ${name} found`);
+};
+export { FieldsetWithContext };

package/Fieldset/index.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { FieldsetLabelProps, FieldsetCaptionProps, FieldsetBodyProps } from '@digigov/form/Fieldset/types';
-import Fieldset from '@digigov/react-core/Fieldset';
+import type { FieldsetLabelProps, FieldsetCaptionProps, FieldsetBodyProps } from './types.js';
+import { Fieldset } from '@digigov/react-core/Fieldset';
 export declare const FieldsetLabel: React.FC<FieldsetLabelProps>;
 export declare const FieldsetCaption: React.FC<FieldsetCaptionProps>;
 export declare const FieldsetBody: React.FC<FieldsetBodyProps>;

package/Fieldset/index.js

@@ -1,32 +1,18 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-var _excluded = ["children"],
-  _excluded2 = ["children"];
-import React from 'react';
-import Fieldset from '@digigov/react-core/Fieldset';
-import FieldsetLegend from '@digigov/react-core/FieldsetLegend';
-import Hint from '@digigov/react-core/Hint';
-import Grid from '@digigov/ui/layouts/Grid';
-import NormalText from '@digigov/ui/typography/NormalText';
-export var FieldsetLabel = function FieldsetLabel(_ref) {
-  var children = _ref.children,
-    props = _objectWithoutProperties(_ref, _excluded);
-  return /*#__PURE__*/React.createElement(FieldsetLegend, _extends({
-    heading: true,
-    size: "xl"
-  }, props), children);
-};
-export var FieldsetCaption = function FieldsetCaption(_ref2) {
-  var children = _ref2.children,
-    props = _objectWithoutProperties(_ref2, _excluded2);
-  return /*#__PURE__*/React.createElement(Hint, props, children);
-};
-export var FieldsetBody = function FieldsetBody(_ref3) {
-  var children = _ref3.children;
-  return /*#__PURE__*/React.createElement(Grid, {
-    item: true,
-    xs: 12
-  }, /*#__PURE__*/React.createElement(NormalText, null, children));
-};
-export { Fieldset };
-export default Fieldset;
+import react from "react";
+import { Fieldset } from "@digigov/react-core/Fieldset/index.js";
+import { FieldsetLegend } from "@digigov/ui/form/FieldContainer/index.js";
+import { Grid } from "@digigov/ui/layouts/Grid/index.js";
+import { Hint } from "@digigov/ui/typography/Hint/index.js";
+import { NormalText } from "@digigov/ui/typography/NormalText/index.js";
+const FieldsetLabel = ({ children, ...props })=>/*#__PURE__*/ react.createElement(FieldsetLegend, {
+        heading: true,
+        size: "xl",
+        ...props
+    }, children);
+const FieldsetCaption = ({ children, ...props })=>/*#__PURE__*/ react.createElement(Hint, props, children);
+const FieldsetBody = ({ children })=>/*#__PURE__*/ react.createElement(Grid, {
+        item: true,
+        xs: 12
+    }, /*#__PURE__*/ react.createElement(NormalText, null, children));
+const src_Fieldset = Fieldset;
+export { Fieldset, FieldsetBody, FieldsetCaption, FieldsetLabel, src_Fieldset as default };

package/Fieldset/types.d.ts

@@ -1,8 +1,9 @@
-import { FieldsetLegendProps } from '@digigov/react-core/FieldsetLegend';
-import { HintProps } from '@digigov/react-core/Hint';
+import type { FieldsetLegendProps } from '@digigov/ui/form/FieldContainer';
+import type { HintProps } from '@digigov/ui/typography/Hint';
 export interface FieldsetLabelProps extends FieldsetLegendProps {
 }
 export interface FieldsetCaptionProps extends HintProps {
 }
 export interface FieldsetBodyProps {
+    children?: React.ReactNode;
 }

package/FormBuilder/index.d.ts

@@ -1,2 +1,9 @@
-import { FormBuilder } from '@digigov/form/FormBuilder/FormBuilder';
+import React from 'react';
+import { useFormContext } from '../FormContext.js';
+import type { FormBaseProps, FormBuilderProps } from '../types.js';
+declare const FormBase: React.ForwardRefExoticComponent<FormBaseProps & React.RefAttributes<HTMLFormElement>>;
+declare const useFormValues: () => import("react-hook-form").FieldValues;
+declare const FormBuilder: React.ForwardRefExoticComponent<FormBuilderProps & React.RefAttributes<HTMLFormElement>>;
+export declare const ControlledFormBuilder: (props: any) => React.JSX.Element;
 export default FormBuilder;
+export { useFormContext, useFormValues, FormBase };