@digigov/form 2.0.0-d0adc9fb → 2.0.0-d2ffc726

package/src/Field/FieldBase.tsx

@@ -1,38 +1,50 @@
-import React from 'react';
+import React, { useContext, useEffect } from 'react';
 import { Controller } from 'react-hook-form';
+import { ErrorGroupContext } from '@digigov/form/Field/ErrorGroup';
 import FieldBaseContainer from '@digigov/form/Field/FieldBaseContainer';
-import { FieldBaseProps } from '@digigov/form/Field/types';
+import type { FieldBaseProps } from '@digigov/form/Field/types';
+
+export const FieldBase: React.FC<FieldBaseProps> = ({
+  required,
+  name,
+  component: Component,
+  wrapper,
+  control,
+  type,
+  controlled = false,
+  enabled = true,
+  editable,
+  defaultValue,
+  label,
+  extra = {},
+  layout,
+  error,
+  register,
+  ...componentProps
+}) => {
+  const errorGroupContext = useContext(ErrorGroupContext);
+
+  useEffect(() => {
+    if (errorGroupContext) {
+      errorGroupContext.setError(name, label, error);
+    }
+  }, [error, name, errorGroupContext?.setError]);
 
-export const FieldBase: React.FC<FieldBaseProps> = (props) => {
-  const {
-    required,
-    name,
-    component: Component,
-    wrapper,
-    control,
-    type,
-    controlled = false,
-    enabled = true,
-    editable,
-    defaultValue,
-    label,
-    extra = {},
-    layout,
-    error,
-    register,
-    ...componentProps
-  } = props;
   if (!enabled) {
     return null;
   }
+
   if (controlled) {
     return (
       <FieldBaseContainer
         label={label}
         layout={layout}
-        error={error}
+        register={register}
+        error={errorGroupContext ? undefined : error}
+        hasError={!!error}
         wrapper={wrapper}
         name={name}
+        controlled={controlled}
       >
         <Controller
           control={control}
@@ -42,8 +54,7 @@ export const FieldBase: React.FC<FieldBaseProps> = (props) => {
               <Component
                 {...field}
                 control={control}
-                ref={undefined}
-                defaultValue={defaultValue}
+                defaultValue={defaultValue ?? field.value}
                 extra={extra}
                 error={!!error}
                 type={type}
@@ -64,7 +75,9 @@ export const FieldBase: React.FC<FieldBaseProps> = (props) => {
     <FieldBaseContainer
       label={label}
       layout={layout}
-      error={error}
+      register={register}
+      error={errorGroupContext ? undefined : error}
+      hasError={!!error}
       wrapper={wrapper}
       name={name}
     >
@@ -79,6 +92,7 @@ export const FieldBase: React.FC<FieldBaseProps> = (props) => {
           aria-describedby={error && `${name}-error`}
           required={required}
           disabled={editable === false}
+          defaultValue={defaultValue}
           {...componentProps}
         />
       ) : (
@@ -89,11 +103,11 @@ export const FieldBase: React.FC<FieldBaseProps> = (props) => {
           error={!!error}
           extra={extra}
           type={type}
+          defaultValue={defaultValue}
           aria-required={!!required}
           aria-describedby={error && `${name}-error`}
           required={required}
           disabled={editable === false}
-          ref={undefined}
           {...componentProps}
         />
       )}

package/src/Field/FieldBaseContainer.tsx

@@ -1,59 +1,81 @@
+import type { ComponentRef } from 'react';
 import React from 'react';
-import { FieldContainerProps } from '@digigov/form/Field/types';
+import type { FieldContainerProps } from '@digigov/form/Field/types';
 import Label from '@digigov/form/inputs/Label';
 import { ErrorMessage } from '@digigov/react-core/ErrorMessage';
 import FieldContainer from '@digigov/react-core/FieldContainer';
-import CoreFieldset from '@digigov/react-core/Fieldset';
+import Fieldset from '@digigov/react-core/Fieldset';
 import FieldsetLegend from '@digigov/react-core/FieldsetLegend';
 import LabelContainer from '@digigov/react-core/LabelContainer';
 import { useTranslation } from '@digigov/ui/i18n';
 import { Hint } from '@digigov/ui/typography/Hint';
 
-export const FieldBaseContainer: React.FC<FieldContainerProps> = ({
-  name,
-  wrapper,
-  label,
-  children,
-  error,
-  layout,
-}) => {
-  const { t } = useTranslation();
-  const errorMessage = error?.message.key
-    ? error.message.key
-    : error?.message || '';
-  const errorContext = error?.message.context || {};
-  if (wrapper === 'fieldset') {
-    return (
-      <FieldContainer error={!!error} {...layout}>
-        <CoreFieldset>
-          <FieldsetLegend size="sm">{label && label.primary}</FieldsetLegend>
-          {label && label.secondary && <Hint>{t(label.secondary)}</Hint>}
-          {error && (
-            <ErrorMessage id={`${name}-error`}>
-              {t(errorMessage, errorContext)}
-            </ErrorMessage>
-          )}
-          {children}
-          {label && label.hint && <Hint size="sm">{label.hint}</Hint>}
-        </CoreFieldset>
-      </FieldContainer>
-    );
-  } else {
-    return (
-      <FieldContainer error={!!error} {...layout}>
-        <LabelContainer>
-          {label && <Label label={label} />}
-          {error && (
-            <ErrorMessage id={`${name}-error`}>
-              {t(errorMessage, errorContext)}
-            </ErrorMessage>
-          )}
-          {children}
-          {label && label.hint && <Hint size="sm">{label.hint}</Hint>}
-        </LabelContainer>
-      </FieldContainer>
-    );
+export const FieldBaseContainer = React.forwardRef<
+  ComponentRef<typeof Fieldset>,
+  FieldContainerProps
+>(
+  (
+    {
+      name,
+      wrapper,
+      label,
+      children,
+      error,
+      hasError,
+      layout,
+      controlled,
+      labelSize = 'sm',
+    },
+    ref
+  ) => {
+    const { t } = useTranslation();
+    const errorMessage = error?.message.key
+      ? error.message.key
+      : error?.message || '';
+    const errorContext = error?.message.context || {};
+    if (wrapper === 'fieldset') {
+      return (
+        <FieldContainer error={hasError} {...layout}>
+          <Fieldset
+            ref={ref}
+            className="outline-none"
+            {...(controlled && {
+              tabIndex: -1,
+            })}
+          >
+            <FieldsetLegend size={labelSize}>
+              {label && label.primary}
+            </FieldsetLegend>
+            {label && label.secondary && <Hint>{t(label.secondary)}</Hint>}
+            {error && (
+              <ErrorMessage id={`${name}-error`}>
+                {t(errorMessage, errorContext)}
+              </ErrorMessage>
+            )}
+            {children}
+            {label && label.hint && <Hint size="sm">{label.hint}</Hint>}
+          </Fieldset>
+        </FieldContainer>
+      );
+    } else {
+      return (
+        <FieldContainer error={hasError} {...layout}>
+          <LabelContainer>
+            {label && <Label label={label} />}
+            {error && (
+              <ErrorMessage id={`${name}-error`}>
+                {t(errorMessage, errorContext)}
+              </ErrorMessage>
+            )}
+            {children}
+            {label && label.hint && <Hint size="sm">{label.hint}</Hint>}
+          </LabelContainer>
+        </FieldContainer>
+      );
+    }
   }
-};
+);
+
+FieldBaseContainer.displayName = 'FieldBaseContainer';
 
 export default FieldBaseContainer;

package/src/Field/FieldConditional.tsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import { useWatch } from 'react-hook-form';
 import { FieldBase } from '@digigov/form/Field/FieldBase';
-import {
+import type {
   ChildFieldMemoProps,
   FieldConditionalProps,
 } from '@digigov/form/Field/types';
@@ -13,6 +13,7 @@ const ChildFieldMemo = React.memo(
     field,
     control,
     reset,
+    resetField,
     register,
     error,
     Field,
@@ -27,6 +28,7 @@ const ChildFieldMemo = React.memo(
         Field={Field}
         name={newField.key}
         reset={reset}
+        resetField={resetField}
         control={control}
         register={register}
         error={error}
@@ -54,6 +56,7 @@ export const FieldConditional: React.FC<FieldConditionalProps> = ({
   field,
   register,
   reset,
+  resetField,
   error,
   Field,
 }) => {
@@ -76,6 +79,7 @@ export const FieldConditional: React.FC<FieldConditionalProps> = ({
       control={control}
       register={register}
       reset={reset}
+      resetField={resetField}
       error={error}
       Field={Field}
     />

package/src/Field/doc.mdx

@@ -3,4 +3,205 @@ title: Form
 parent: docs/form/components
 ---
 
-hello md
+# Field
+
+Field allow users to create different types of inputs based on data that is described by a particular config schema.
+
+```jsx
+import React from 'react';
+import FormBuilder, { Field } from '@digigov/form';
+import { Button } from '@digigov/ui/form/Button';
+
+const fields = [
+  {
+    key: 'first_name',
+    type: 'string',
+    required: true,
+    label: {
+      primary: 'Ποιo είναι το όνομά σας;',
+    },
+  },
+];
+
+export const MyComponent = () => (
+  <FormBuilder onSubmit={(data) => console.log(data)}>
+    {fields.map(({ key, ...field }) => {
+      return <Field {...field} name={key} key={key} />;
+    })}
+    <Button type="submit">Συνέχεια</Button>
+  </FormBuilder>
+);
+export default MyComponent;
+```
+
+## Accessibility & Usability
+
+Our goal is to create semantically correct and valid forms, which means
+we must avoid mixing form-related HTML elements (like form, input, label) with generic
+ones (such as div, cards, or custom components). For instance, if a paragraph element is
+placed inside a form, React will display warnings in the console. Rather than building overly
+complex interfaces that attempt to accomplish too much too quickly, Digigov Form encourages
+using forms in their intended way—filling out and validating inputs, and then submitting the form
+as a whole.
+
+Additionally, we must ensure our interfaces are fully accessible to screen readers and other
+assistive technologies. This is why we designed the flow to be as guided and recoverable as possible.
+Forms and fields should be clear and logical, reading like well-written text for the users.
+If validation fails, the system provides users with meaningful error messages and clear instructions on how to correct the errors.
+Once validation is successful, the data can be submitted. It is crucial to provide helpful information to users at each step.
+Therefore, we should avoid relying on flashy “magic” UX solutions that assume users have advanced digital skills,
+as these are often intended for expert use cases.
+
+## Introducing the Field component
+
+Field is a component that creates `form` inputs dynamically based on a `data config` schema.
+The config structure is a `key-value` pair of data that describes the input fields and its usage.
+In order to create an input, we need to provide a specific type of input for each field,
+and we can use the `type` property for this.
+
+## Field types
+
+The `type` property determines the type of input field to be rendered. Below are the available types and their descriptions.
+
+| Type              | Input Description                                                                                                                  |
+| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| `int`             | A whole number.                                                                                                                    |
+| `string`          | A text string (e.g., name, address).                                                                                               |
+| `text`            | A larger text input, suitable for paragraphs or multiline text.                                                                    |
+| `boolean`         | A binary value, typically a checkbox or toggle (true/false).                                                                       |
+| `email`           | An email address (e.g., example@example.com).                                                                                      |
+| `uuid4`           | A universally unique identifier (UUID) in version 4 format.                                                                        |
+| `choice:multiple` | A selection of multiple options from a list (e.g., checkboxes).                                                                    |
+| `choice:single`   | A single selection from a list (e.g., radio buttons).                                                                              |
+| `mobile_phone`    | A phone number, typically with country code (e.g., +1-234-567-890).                                                                |
+| `date`            | A date input, typically in the format YYYY-MM-DD.                                                                                  |
+| `datetime`        | A date and time input, typically in the format YYYY-MM-DD HH:MM:SS.                                                                |
+| `otp`             | A one-time password, typically a short numeric or alphanumeric string.                                                             |
+| `afm`             | A Greek Tax Identification Number (AFM).                                                                                           |
+| `iban`            | An International Bank Account Number (IBAN).                                                                                       |
+| `file`            | A file upload input (e.g., for documents, images).                                                                                 |
+| `image`           | A file input that specifically handles images.                                                                                     |
+| `postal_code`     | A postal code input (e.g., ZIP code, postcode).                                                                                    |
+| `phone_number`    | A phone number input (e.g., with or without country code).                                                                         |
+| `array`           | A list of values, typically displayed as multiple inputs ([MultiplicityField](/components/@digigov/form/MultiplicityField.html)).  |
+| `object`          | A structured data object, often used for more complex or nested forms.                                                             |
+
+## Field properties
+
+The Field component accepts several properties, that describes the input fields and its usage.
+
+| Property       | Type                                                                                      | Description                                                                 |
+| -------------- | ----------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| `key`          | `string`                                                                                  | The name of the field (TODO: rename to `name`).                             |
+| `type`         | Describes the format of each field, e.g., `type: 'string'` is a simple input format field | The type of input field. Defines the kind of value it accepts.              |
+| `trim`         | `boolean`                                                                                 | If `true`, trims the input value.                                           |
+| `component`    | `any`                                                                                     | A custom React component for the input field.                               |
+| `autoComplete` | `string`                                                                                  | The `autocomplete` attribute value for the input field (e.g., 'on', 'off'). |
+| `maxLength`    | `number`                                                                                  | The maximum number of characters the input can accept.                      |
+| `condition`    | `Record<string, FieldCondition>`                                                          | Conditions for when the field should be shown, enabled, or validated.       |
+| `controlled`   | `boolean`                                                                                 | If `true`, the input value is controlled by React state.                    |
+| `label`        | `FieldLabelProps`                                                                         | The label associated with the input field.                                  |
+| `extra`        | `Record<string, any>`                                                                     | Extra custom attributes or settings for the field.                          |
+| `editable`     | `boolean`                                                                                 | If `false`, the field cannot be edited.                                     |
+| `variant`      | `'inline' \| 'dialog'`                                                                    | Defines the display variant of the field (e.g., inline or in a dialog).     |
+| `required`     | `boolean`                                                                                 | If `true`, the field is required to be filled.                              |
+| `enabled`      | `boolean`                                                                                 | If `false`, the field is disabled and cannot be interacted with.            |
+| `disabled`     | `boolean`                                                                                 | If `true`, the field is disabled.                                           |
+| `layout`       | `Record<string, GridProps['xs' \| 'sm' \| 'md' \| 'lg' \| 'xl']>`                         | Defines the layout settings for the field (grid system).                    |
+| `validators`   | `ValidatorSchema[]`                                                                       | Array of validators to be applied to the input field.                       |
+| `wrapper`      | `'label' \| 'fieldset'`                                                                   | Defines the wrapping element for the field (label or fieldset).             |
+| `maxWidth`     | `string`                                                                                  | The maximum width of the field.                                             |
+| `maxHeight`    | `string`                                                                                  | The maximum height of the field.                                            |
+| `width`        | `string`                                                                                  | The width of the field.                                                     |
+
+### How to use it
+
+The `Field` component is a fundamental building block of the `form`.
+We can implement a `Field` by using the `data config` or we can fill the `Field` directly with its properties.
+
+First, we need to import the `FormBuilder` component from the `@digigov/form` path.
+
+```jsx pure
+import React from 'react';
+import FormBuilder from '@digigov/form';
+import Button from '@digigov/ui/form/Button';
+
+export default function MyFieldComponent() {
+  return (
+    <FormBuilder>
+      {/* this is where all fields will eventually be rendered */}
+      <Button type="submit">Συνέχεια</Button>
+    </FormBuilder>
+  );
+}
+```
+
+#### Data config
+
+The `data config` is an array of objects that contains the configuration for each field.
+
+```jsx pure
+const fields = [
+  {
+    key: 'first_name',
+    type: 'string',
+    required: true,
+    label: {
+      primary: 'Ποιo είναι το όνομά σας;',
+    },
+  },
+];
+```
+
+Then we can use the `fields` array to render the Field(s).
+
+```jsx pure
+import React from 'react';
+import FormBuilder, { Field } from '@digigov/form';
+import { Button } from '@digigov/ui/form/Button';
+
+const fields = [
+  {
+    key: 'first_name',
+    type: 'string',
+    required: true,
+    label: {
+      primary: 'Ποιo είναι το όνομά σας;',
+    },
+  },
+];
+
+export const MyComponent = () => (
+  <FormBuilder onSubmit={(data) => console.log(data)}>
+    {fields.map(({ key, ...field }) => {
+      return <Field {...field} name={key} key={key} />;
+    })}
+    <Button type="submit">Συνέχεια</Button>
+  </FormBuilder>
+);
+export default MyComponent;
+```
+
+#### Directly
+
+We can also use the `Field` component directly and pass the properties to it.
+
+```jsx pure
+import React from 'react';
+import FormBuilder, { Field } from '@digigov/form';
+import { Button } from '@digigov/ui/form/Button';
+
+export const MyComponent = () => (
+  <FormBuilder onSubmit={(data) => console.log(data)}>
+    <Field
+      key="first_name"
+      name="first_name"
+      label={{ primary: 'Οχήματα' }}
+      type="sting"
+      required
+    />
+    <Button type="submit">Συνέχεια</Button>
+  </FormBuilder>
+);
+export default MyComponent;
+```

package/src/Field/index.tsx

@@ -1,22 +1,13 @@
 import React, { useMemo } from 'react';
 import { FieldBase } from '@digigov/form/Field/FieldBase';
 import FieldConditional from '@digigov/form/Field/FieldConditional';
-import {
-  FieldWithCondition,
-  CalculatedField,
-  FieldProps,
-} from '@digigov/form/Field/types';
-import {
-  FIELD_COMPONENTS,
-  ALTERNATIVE_COMPONENTS,
-} from '@digigov/form/Field/utils';
-import { calculateField } from '@digigov/form/Field/utils/calculateField';
+import type { FieldWithCondition, FieldProps } from '@digigov/form/Field/types';
+import { resolveField } from '@digigov/form/Field/utils/resolveField';
 import { useField } from '@digigov/form/Field/utils/useField';
 import FieldArray from '@digigov/form/FieldArray';
 import Multiplicity from '@digigov/form/MultiplicityField';
 export const Field: React.FC<FieldProps> = ({
   name,
-  disabled,
   children,
   ...customField
 }) => {
@@ -25,6 +16,7 @@ export const Field: React.FC<FieldProps> = ({
     control,
     register,
     reset,
+    resetField,
     error,
     componentRegistry,
     formState,
@@ -33,35 +25,27 @@ export const Field: React.FC<FieldProps> = ({
     unregister,
     trigger,
     clearErrors,
+    registerFieldFocus,
   } = useField(name, customField?.type ? customField : null);
-  const calculatedField: CalculatedField = useMemo(
-    () =>
-      calculateField(
-        children,
-        field,
-        {
-          ...FIELD_COMPONENTS,
-          ...componentRegistry,
-        },
-        ALTERNATIVE_COMPONENTS
-      ),
+  const resolvedField = useMemo(
+    () => resolveField(children, field, componentRegistry),
     [field]
   );
-
-  if (calculatedField.condition) {
+  if (resolvedField.condition) {
     return (
       <FieldConditional
         control={control}
         reset={reset}
+        resetField={resetField}
         register={register}
-        field={calculatedField as FieldWithCondition}
+        field={resolvedField as FieldWithCondition}
         error={error}
         Field={Field}
       />
     );
   }
-  if (calculatedField.type === 'array' && !calculatedField.multiplicity) {
-    calculatedField.name = name;
+  if (resolvedField.type === 'array' && !resolvedField.multiplicity) {
+    resolvedField.name = name;
     return (
       <FieldArray
         control={control}
@@ -74,15 +58,14 @@ export const Field: React.FC<FieldProps> = ({
         formState={formState}
         Field={Field}
         reset={reset}
-        {...calculatedField}
+        resetField={resetField}
+        registerFieldFocus={registerFieldFocus}
+        {...resolvedField}
       />
     );
   }
-  if (
-    calculatedField.type === 'array' &&
-    calculatedField.multiplicity === true
-  ) {
-    calculatedField.name = name;
+  if (resolvedField.type === 'array' && resolvedField.multiplicity === true) {
+    resolvedField.name = name;
     return (
       <Multiplicity
         control={control}
@@ -94,20 +77,27 @@ export const Field: React.FC<FieldProps> = ({
         setValue={setValue}
         getValues={getValues}
         unregister={unregister}
+        resetField={resetField}
         Field={Field}
-        {...calculatedField}
+        {...resolvedField}
       />
     );
   }
+  const editable =
+    customField.editable === false || customField.disabled === true
+      ? false
+      : true;
+  const customError = error ? error : formState?.errors[name];
   return (
     <FieldBase
-      {...calculatedField}
+      {...resolvedField}
+      editable={editable}
       name={name}
-      disabled={disabled}
       control={control}
       register={register}
       reset={reset}
-      error={error}
+      error={customError}
+      resetField={resetField}
       Field={Field}
     />
   );