@digigov/form 2.0.0-2177f152 → 2.0.0-2271444d

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,12 +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,75 +1,66 @@
-import React from "react";
-import { useFieldArray } from "react-hook-form";
-import { FieldBaseContainer } from "@digigov/form/Field/FieldBaseContainer";
-import { FieldObject } from "@digigov/form/FieldObject";
-import { FieldsetLabel, Fieldset } from "@digigov/form/Fieldset";
-import { Card } from "@digigov/ui/content/Card";
-import { Button } from "@digigov/ui/form/Button";
-import { Hint } from "@digigov/ui/typography/Hint";
-const FieldArray = ({
-  name,
-  register,
-  control,
-  formState,
-  error,
-  layout,
-  label,
-  Field,
-  ...customField
-}) => {
-  const { fields, append, remove } = useFieldArray({
-    control,
-    name
-  });
-  return /* @__PURE__ */ React.createElement(
-    FieldBaseContainer,
-    {
-      label,
-      layout,
-      error: formState.isSubmitted && !formState.isSubmitting && error?.message && error ? error : void 0,
-      wrapper: "fieldset",
-      name
-    },
-    fields.length === 0 && /* @__PURE__ */ React.createElement(Hint, null, customField.extra?.label.object?.nothing_added),
-    fields.map((field, index) => /* @__PURE__ */ React.createElement(Card, { variant: "border", key: field.id }, /* @__PURE__ */ React.createElement(Fieldset, null, /* @__PURE__ */ React.createElement(FieldsetLabel, null, customField.extra?.label.object.title, " ", index + 1), /* @__PURE__ */ React.createElement(
-      FieldObject,
-      {
-        name: `${name}.${index}`,
-        error: Array.isArray(error) && error[index],
-        formState,
-        register,
-        control,
-        ...customField.extra?.of,
-        Field
-      }
-    ), /* @__PURE__ */ React.createElement(
-      Button,
-      {
-        name: `${name}-object-remove`,
-        type: "button",
-        color: "warning",
-        onClick: () => remove(index)
-      },
-      customField.extra?.label.object?.delete
-    )))),
-    /* @__PURE__ */ React.createElement(
-      Button,
-      {
-        type: "button",
-        name: `${name}-add-object`,
-        color: "secondary",
-        onClick: (ev) => {
-          ev.preventDefault();
-          append({});
-        }
-      },
-      customField.extra?.label.object?.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
+    }));
 };
-var FieldArray_default = FieldArray;
-export {
-  FieldArray,
-  FieldArray_default as default
-};
-//# sourceMappingURL=index.js.map
+const src_FieldArray = FieldArray;
+export { FieldArray, src_FieldArray as default };

package/FieldObject/index.d.ts

@@ -1,25 +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,72 +1,55 @@
-import React, { useMemo } from "react";
-import { FieldBase } from "@digigov/form/Field/FieldBase";
-import {
-  FIELD_COMPONENTS,
-  ALTERNATIVE_COMPONENTS
-} from "@digigov/form/Field/utils";
-import { calculateField } from "@digigov/form/Field/utils/calculateField";
-import { Fieldset, FieldsetCaption } from "@digigov/form/Fieldset";
-import { FieldsetLegend } from "@digigov/ui/form/FieldContainer";
-import { useTranslation } from "@digigov/ui/i18n";
-const FieldObject = ({
-  name,
-  label,
-  extra,
-  control,
-  register,
-  reset,
-  formState,
-  error,
-  Field
-}) => {
-  const { t } = useTranslation();
-  return /* @__PURE__ */ React.createElement(Fieldset, null, label?.primary && /* @__PURE__ */ React.createElement(FieldsetLegend, { size: "sm" }, t(label.primary)), label?.secondary && /* @__PURE__ */ React.createElement(FieldsetCaption, null, t(label.secondary)), extra?.fields.map((field) => /* @__PURE__ */ React.createElement(
-    FieldObjectItem,
-    {
-      key: `${name}.${field.key}`,
-      name: `${name}.${field.key}`,
-      control,
-      register,
-      reset,
-      field,
-      error: error && error[field.key],
-      formState,
-      Field
-    }
-  )));
+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
+        })));
 };
-const FieldObjectItem = ({
-  name,
-  children,
-  field,
-  error,
-  control,
-  formState,
-  reset,
-  register,
-  Field
-}) => {
-  const calculatedField = useMemo(
-    () => calculateField(children, field, FIELD_COMPONENTS, ALTERNATIVE_COMPONENTS),
-    [field]
-  );
-  const customError = error ? error : formState?.errors[name];
-  return /* @__PURE__ */ React.createElement(
-    FieldBase,
+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
+        });
+    }
     {
-      ...calculatedField,
-      name,
-      Field,
-      control,
-      reset,
-      register,
-      error: customError
+        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
+        });
     }
-  );
-};
-var FieldObject_default = FieldObject;
-export {
-  FieldObject,
-  FieldObject_default as default
 };
-//# sourceMappingURL=index.js.map
+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,5 +1,5 @@
 import React from 'react';
-import { FieldsetLabelProps, FieldsetCaptionProps, FieldsetBodyProps } from '@digigov/form/Fieldset/types';
+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>;

package/Fieldset/index.js

@@ -1,30 +1,18 @@
-import React from "react";
-import { Fieldset } from "@digigov/react-core/Fieldset";
-import { FieldsetLegend } from "@digigov/ui/form/FieldContainer";
-import { Grid } from "@digigov/ui/layouts/Grid";
-import { Hint } from "@digigov/ui/typography/Hint";
-import { NormalText } from "@digigov/ui/typography/NormalText";
-const FieldsetLabel = ({
-  children,
-  ...props
-}) => {
-  return /* @__PURE__ */ React.createElement(FieldsetLegend, { heading: true, size: "xl", ...props }, children);
-};
-const FieldsetCaption = ({
-  children,
-  ...props
-}) => {
-  return /* @__PURE__ */ React.createElement(Hint, { ...props }, children);
-};
-const FieldsetBody = ({ children }) => {
-  return /* @__PURE__ */ React.createElement(Grid, { item: true, xs: 12 }, /* @__PURE__ */ React.createElement(NormalText, null, children));
-};
-var Fieldset_default = Fieldset;
-export {
-  Fieldset,
-  FieldsetBody,
-  FieldsetCaption,
-  FieldsetLabel,
-  Fieldset_default as default
-};
-//# sourceMappingURL=index.js.map
+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,5 +1,5 @@
-import { FieldsetLegendProps } from '@digigov/ui/form/FieldContainer';
-import { HintProps } from '@digigov/ui/typography/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 {

package/FormBuilder/index.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
-import { FormBaseProps, FormBuilderProps } from '@digigov/form/types';
+import { useFormContext } from '../FormContext.js';
+import type { FormBaseProps, FormBuilderProps } from '../types.js';
 declare const FormBase: React.ForwardRefExoticComponent<FormBaseProps & React.RefAttributes<HTMLFormElement>>;
-declare const useFormContext: () => import("@digigov/form/types").FormContextProps;
 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;