@digigov/form 1.2.0-a7ffb5dc → 2.0.0-0138f8bd

package/src/Field/FieldConditional.tsx

@@ -1,11 +1,11 @@
 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';
-import { evaluateFieldWithConditions } from '@digigov/form/Field/utils';
+import { evaluateFieldWithConditions } from '@digigov/form/Field/utils/evaluateFieldWithConditions';
 
 const ChildFieldMemo = React.memo(
   function ChildField({
@@ -13,8 +13,10 @@ const ChildFieldMemo = React.memo(
     field,
     control,
     reset,
+    resetField,
     register,
     error,
+    Field,
   }: ChildFieldMemoProps) {
     const newField = evaluateFieldWithConditions(
       field,
@@ -23,8 +25,10 @@ const ChildFieldMemo = React.memo(
     return (
       <FieldBase
         {...newField}
+        Field={Field}
         name={newField.key}
         reset={reset}
+        resetField={resetField}
         control={control}
         register={register}
         error={error}
@@ -52,7 +56,9 @@ export const FieldConditional: React.FC<FieldConditionalProps> = ({
   field,
   register,
   reset,
+  resetField,
   error,
+  Field,
 }) => {
   const dependencyKeys = Object.keys(field.condition);
   const dependencyValues = useWatch({
@@ -73,7 +79,9 @@ export const FieldConditional: React.FC<FieldConditionalProps> = ({
       control={control}
       register={register}
       reset={reset}
+      resetField={resetField}
       error={error}
+      Field={Field}
     />
   );
 };

package/src/Field/doc.mdx

@@ -0,0 +1,207 @@
+---
+title: Form
+parent: docs/form/components
+---
+
+# 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,15 +1,11 @@
 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 { useField, calculateField } from '@digigov/form/Field/utils';
+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,
   children,
@@ -20,6 +16,7 @@ export const Field: React.FC<FieldProps> = ({
     control,
     register,
     reset,
+    resetField,
     error,
     componentRegistry,
     formState,
@@ -28,40 +25,47 @@ export const Field: React.FC<FieldProps> = ({
     unregister,
     trigger,
     clearErrors,
+    registerFieldFocus,
   } = useField(name, customField?.type ? customField : null);
-  const calculatedField: CalculatedField = useMemo(
-    () => calculateField(children, field, componentRegistry),
+  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}
+        trigger={trigger}
         register={register}
+        clearErrors={clearErrors}
         error={error}
+        getValues={getValues}
+        setValue={setValue}
         formState={formState}
-        {...calculatedField}
+        Field={Field}
+        reset={reset}
+        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}
@@ -73,18 +77,28 @@ export const Field: React.FC<FieldProps> = ({
         setValue={setValue}
         getValues={getValues}
         unregister={unregister}
-        {...calculatedField}
+        resetField={resetField}
+        Field={Field}
+        {...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}
       control={control}
       register={register}
       reset={reset}
-      error={error}
+      error={customError}
+      resetField={resetField}
+      Field={Field}
     />
   );
 };

package/src/Field/types.tsx

@@ -1,13 +1,81 @@
-import React from 'react';
-import { ErrorOption, UseFormReturn } from 'react-hook-form';
-import { FieldSpec } from '@digigov/form/types';
-import { FieldCondition, FormData } from '@digigov/form/types';
+import type React from 'react';
+import type { ErrorOption, UseFormReturn, UseFormProps } from 'react-hook-form';
+import type { FieldComponentRegistry } from '@digigov/form/inputs/registry';
+import type { registerFieldFocus } from '@digigov/form/types';
+import type { ValidatorSchema } from '@digigov/form/validators/types';
+import type { FieldsetLegendProps } from '@digigov/ui/form/FieldContainer';
+import type { GridProps } from '@digigov/ui/layouts/Grid';
 
+export interface FieldLabelProps {
+  primary?: string;
+  secondary?: string;
+  hint?: string;
+}
+
+export interface FieldSpec {
+  key: string; // !TODO rename key to name;
+  type?:
+    | 'int'
+    | 'string'
+    | 'text'
+    | 'boolean'
+    | 'email'
+    | 'uuid4'
+    | 'choice:multiple'
+    | 'choice:single'
+    | 'mobile_phone'
+    | 'date'
+    | 'datetime'
+    | 'otp'
+    | 'afm'
+    | 'amka'
+    | 'iban'
+    | 'file'
+    | 'image'
+    | 'postal_code'
+    | 'phone_number'
+    | 'array'
+    | 'object';
+  trim?: boolean;
+  component?: any;
+  autoComplete?: string;
+  placeholder?: string;
+  maxLength?: number;
+  condition?: Record<string, FieldCondition>;
+  controlled?: boolean;
+  label?: FieldLabelProps;
+  extra?: Record<string, any>;
+  editable?: boolean;
+  variant?: 'inline' | 'dialog';
+  required?: boolean;
+  enabled?: boolean;
+  disabled?: boolean; // TODO: keep disabled or editable
+  layout?: Record<
+    string,
+    | GridProps['xs']
+    | GridProps['sm']
+    | GridProps['md']
+    | GridProps['lg']
+    | GridProps['xl']
+  >;
+  validators?: ValidatorSchema[];
+  wrapper?: 'label' | 'fieldset';
+  maxWidth?: string;
+  maxHeight?: string;
+  width?: string;
+}
+
+export interface FieldCondition {
+  is: string | string[] | number | number[] | boolean | boolean[];
+  then?: Partial<FieldSpec>;
+  else?: Partial<FieldSpec>;
+}
 export interface ChildFieldMemoProps extends FieldConditionalProps {
   dependencies: FormData;
 }
+export type FormData = UseFormProps['defaultValues'];
 
-export interface FieldWithCondition extends Omit<CalculatedField, 'condition'> {
+export interface FieldWithCondition extends Omit<ResolvedField, 'condition'> {
   condition: Record<string, FieldCondition>;
 }
 
@@ -16,29 +84,31 @@ export interface FieldConditionalProps {
   control: UseFormReturn['control'];
   register: UseFormReturn['register'];
   reset: UseFormReturn['reset'];
+  resetField?: UseFormReturn['resetField'];
   error?: ErrorOption;
+  Field: React.FC<FieldProps>;
 }
 
-export type FieldComponentItem = {
+export interface FieldComponentItem {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   component: any;
   controlled?: boolean;
   wrapper?: FieldSpec['wrapper'];
-};
+}
 
 export interface FieldContainerProps {
   name?: FieldSpec['key'];
+  register: FieldBaseProps['register'];
   layout?: FieldSpec['layout'];
   label?: FieldSpec['label'];
   error?: ErrorOption | Record<string, any>;
+  hasError?: boolean;
   children?: React.ReactNode;
+  controlled?: boolean;
   wrapper?: FieldSpec['wrapper'];
+  labelSize?: FieldsetLegendProps['size'];
 }
 
-export type FieldComponentRegistry = Record<string, FieldComponentItem>;
-
-export type OmittedFieldSpec = Omit<FieldSpec, 'component'>;
-
 export type UnknownValue = never | never[];
 
 export interface ControlledFieldProps {
@@ -51,6 +121,7 @@ export interface ControlledFieldProps {
   error?: boolean;
   name?: string;
   disabled?: boolean;
+  Field?: React.FC<FieldProps>;
 }
 
 export interface UncontrolledFieldProps {
@@ -61,9 +132,10 @@ export interface UncontrolledFieldProps {
   extra?: Record<string, never>;
   type?: string;
   disabled?: boolean;
+  Field: React.FC<FieldProps>;
 }
 
-export interface CalculatedField extends OmittedFieldSpec {
+export interface ResolvedField extends Omit<FieldSpec, 'component'> {
   name: string;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   component: any;
@@ -73,10 +145,12 @@ export interface CalculatedField extends OmittedFieldSpec {
   multiplicity?: boolean;
 }
 
-export interface FieldBaseProps extends CalculatedField {
+export interface FieldBaseProps extends ResolvedField {
   control: UseFormReturn['control'];
   register: UseFormReturn['register'];
   reset: UseFormReturn['reset'];
+  resetField?: UseFormReturn['resetField'];
+  Field?: React.FC<FieldProps>;
 }
 
 export interface FieldProps extends FieldSpec {
@@ -89,6 +163,7 @@ export interface UseFieldProps {
   control: FieldBaseProps['control'];
   register: FieldBaseProps['register'];
   reset: FieldBaseProps['reset'];
+  resetField: FieldBaseProps['resetField'];
   watch: UseFormReturn['watch'];
   formState: UseFormReturn['formState'];
   getFieldState: UseFormReturn['getFieldState'];
@@ -98,5 +173,6 @@ export interface UseFieldProps {
   trigger: UseFormReturn['trigger'];
   clearErrors: UseFormReturn['clearErrors'];
   error?: ErrorOption;
+  registerFieldFocus: registerFieldFocus;
   componentRegistry?: FieldComponentRegistry;
 }

package/src/Field/utils/evaluateFieldWithConditions.ts

@@ -0,0 +1,33 @@
+import type {
+  FieldWithCondition,
+  ResolvedField,
+} from '@digigov/form/Field/types';
+
+export function evaluateFieldWithConditions(
+  field: FieldWithCondition,
+  variables: FormData
+): ResolvedField {
+  const newField = { ...field };
+  if (variables) {
+    for (const key in variables) {
+      if (field.condition[key] && field.condition[key].is) {
+        const is = field.condition[key].is;
+        if (
+          is === variables[key] ||
+          (Array.isArray(variables[key]) && variables[key].includes(is))
+        ) {
+          const then = field.condition[key].then || {};
+          for (const attr in then) {
+            newField[attr] = then[attr];
+          }
+        }
+      } else if (field.condition[key]) {
+        const otherwise = field.condition[key].else || {};
+        for (const attr in otherwise) {
+          newField[attr] = otherwise[attr];
+        }
+      }
+    }
+  }
+  return newField;
+}

package/src/Field/utils/resolveField.ts

@@ -0,0 +1,58 @@
+import type {
+  FieldProps,
+  FieldSpec,
+  ResolvedField,
+} from '@digigov/form/Field/types';
+import {
+  ALTERNATIVE_COMPONENTS,
+  FIELD_COMPONENTS,
+  type FieldComponentRegistry,
+} from '@digigov/form/inputs/registry';
+
+export function resolveField(
+  children: FieldProps['children'],
+  field: FieldSpec,
+  customComponentRegistry?: FieldComponentRegistry
+): ResolvedField {
+  const fieldComponentRegistry = {
+    ...FIELD_COMPONENTS,
+    ...(customComponentRegistry ?? {}),
+  };
+
+  const resolvedField = { ...field };
+
+  if (children) {
+    resolvedField.component = children;
+    resolvedField.controlled = true;
+  } else if (typeof field.component === 'function') {
+    // leave as is
+  } else if (!field.component && !field.type) {
+    resolvedField.component = fieldComponentRegistry.string.component;
+    resolvedField.controlled =
+      fieldComponentRegistry.string?.controlled || false;
+  } else if (
+    typeof field?.extra?.component === 'string' &&
+    ALTERNATIVE_COMPONENTS[field.extra.component]
+  ) {
+    resolvedField.controlled =
+      ALTERNATIVE_COMPONENTS[field.extra.component]?.controlled || false;
+    resolvedField.component =
+      ALTERNATIVE_COMPONENTS[field.extra.component].component;
+    resolvedField.wrapper =
+      ALTERNATIVE_COMPONENTS[field.extra.component].wrapper;
+  } else if (
+    !field.component &&
+    field.type &&
+    fieldComponentRegistry[field.type]
+  ) {
+    resolvedField.component = fieldComponentRegistry[field.type].component;
+    resolvedField.wrapper = fieldComponentRegistry[field.type].wrapper;
+    resolvedField.controlled =
+      fieldComponentRegistry[field.type]?.controlled || false;
+  } else {
+    resolvedField.component = fieldComponentRegistry.string.component;
+    resolvedField.controlled =
+      fieldComponentRegistry.string?.controlled || false;
+  }
+  return resolvedField as ResolvedField;
+}