@digigov/form 2.0.0-8e254888 → 2.0.0-a0ac149e

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,56 +25,49 @@ 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}
         trigger={trigger}
         register={register}
         clearErrors={clearErrors}
-        error={error}
+        error={
+          formState.isSubmitted && !formState.isSubmitting ? error : undefined
+        }
         getValues={getValues}
         setValue={setValue}
         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 +79,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}
     />
   );

package/src/Field/types.tsx

@@ -1,7 +1,10 @@
-import React from 'react';
-import { ErrorOption, UseFormReturn, UseFormProps } from 'react-hook-form';
-import { ValidatorSchema } from '@digigov/form/validators/types';
-import { GridProps } from '@digigov/ui/layouts/Grid';
+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;
@@ -25,6 +28,7 @@ export interface FieldSpec {
     | 'datetime'
     | 'otp'
     | 'afm'
+    | 'amka'
     | 'iban'
     | 'file'
     | 'image'
@@ -35,6 +39,7 @@ export interface FieldSpec {
   trim?: boolean;
   component?: any;
   autoComplete?: string;
+  placeholder?: string;
   maxLength?: number;
   condition?: Record<string, FieldCondition>;
   controlled?: boolean;
@@ -44,7 +49,7 @@ export interface FieldSpec {
   variant?: 'inline' | 'dialog';
   required?: boolean;
   enabled?: boolean;
-  disabled?: boolean;
+  disabled?: boolean; // TODO: keep disabled or editable
   layout?: Record<
     string,
     | GridProps['xs']
@@ -70,7 +75,7 @@ export interface ChildFieldMemoProps extends FieldConditionalProps {
 }
 export type FormData = UseFormProps['defaultValues'];
 
-export interface FieldWithCondition extends Omit<CalculatedField, 'condition'> {
+export interface FieldWithCondition extends Omit<ResolvedField, 'condition'> {
   condition: Record<string, FieldCondition>;
 }
 
@@ -79,6 +84,7 @@ export interface FieldConditionalProps {
   control: UseFormReturn['control'];
   register: UseFormReturn['register'];
   reset: UseFormReturn['reset'];
+  resetField?: UseFormReturn['resetField'];
   error?: ErrorOption;
   Field: React.FC<FieldProps>;
 }
@@ -92,18 +98,17 @@ export interface FieldComponentItem {
 
 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 {
@@ -116,7 +121,7 @@ export interface ControlledFieldProps {
   error?: boolean;
   name?: string;
   disabled?: boolean;
-  Field: React.FC<FieldProps>;
+  Field?: React.FC<FieldProps>;
 }
 
 export interface UncontrolledFieldProps {
@@ -130,7 +135,7 @@ export interface UncontrolledFieldProps {
   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;
@@ -140,11 +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'];
-  Field: React.FC<FieldProps>;
+  resetField?: UseFormReturn['resetField'];
+  Field?: React.FC<FieldProps>;
 }
 
 export interface FieldProps extends FieldSpec {
@@ -157,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'];
@@ -166,5 +173,6 @@ export interface UseFieldProps {
   trigger: UseFormReturn['trigger'];
   clearErrors: UseFormReturn['clearErrors'];
   error?: ErrorOption;
+  registerFieldFocus: registerFieldFocus;
   componentRegistry?: FieldComponentRegistry;
 }

package/src/Field/utils/evaluateFieldWithConditions.ts

@@ -1,9 +1,12 @@
-import { FieldWithCondition, CalculatedField } from '@digigov/form/Field/types';
+import type {
+  FieldWithCondition,
+  ResolvedField,
+} from '@digigov/form/Field/types';
 
 export function evaluateFieldWithConditions(
   field: FieldWithCondition,
   variables: FormData
-): CalculatedField {
+): ResolvedField {
   const newField = { ...field };
   if (variables) {
     for (const key in variables) {

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;
+}

package/src/Field/utils/useField.ts

@@ -1,5 +1,5 @@
 import { useContext, useMemo } from 'react';
-import { FieldSpec, UseFieldProps } from '@digigov/form/Field/types';
+import type { FieldSpec, UseFieldProps } from '@digigov/form/Field/types';
 import { FormContext } from '@digigov/form/FormContext';
 
 export const useField = (
@@ -11,6 +11,7 @@ export const useField = (
     control,
     register,
     reset,
+    resetField,
     trigger,
     clearErrors,
     errors,
@@ -22,6 +23,7 @@ export const useField = (
     getValues,
     unregister,
     formState,
+    registerFieldFocus,
   } = useContext(FormContext);
   if (!registerField) {
     throw new Error(`
@@ -30,11 +32,17 @@ export const useField = (
     `);
   }
   let error = errors[name];
-  const nameIndexRegex = name.match(/^(.*?)\.(\d+)$/);
+
+  const nameIndexRegex = name.match(/^\[*(.*?)\.(\d+)\]*$/);
   if (nameIndexRegex) {
     const [, fieldArrayName, indexStr] = nameIndexRegex;
     error = errors[fieldArrayName]?.[Number(indexStr)];
   }
+  const nestedNameIndexRegex = name.match(/^\[*(.*?)\.(\d+)\.(.*?)\]*$/);
+  if (nestedNameIndexRegex) {
+    const [, fieldArrayName, indexStr, fieldItemName] = nestedNameIndexRegex;
+    error = errors[fieldArrayName]?.[Number(indexStr)]?.[fieldItemName];
+  }
   useMemo(
     () => customField?.type && registerField({ ...customField, key: name }),
     [customField, name, registerField]
@@ -44,6 +52,7 @@ export const useField = (
     control,
     register,
     reset,
+    resetField,
     trigger,
     watch,
     componentRegistry,
@@ -54,5 +63,6 @@ export const useField = (
     unregister,
     formState,
     error,
+    registerFieldFocus,
   };
 };

package/src/FieldArray/BaseFieldArray.tsx

@@ -0,0 +1,97 @@
+import React from 'react';
+import { useFieldArray } from 'react-hook-form';
+import type { FieldArrayProps } from '@digigov/form/FieldArray';
+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';
+
+type BaseFieldArrayProps = Omit<
+  FieldArrayProps,
+  | 'registerFieldFocus'
+  | 'trigger'
+  | 'clearErrors'
+  | 'setValue'
+  | 'reset'
+  | 'resetField'
+>;
+export const BaseFieldArray = React.forwardRef<
+  HTMLButtonElement,
+  BaseFieldArrayProps
+>(
+  (
+    {
+      name,
+      register,
+      control,
+      formState,
+      error,
+      getValues,
+      Field,
+      ...customField
+    },
+    ref
+  ) => {
+    const { append, remove } = useFieldArray({
+      control,
+      name,
+    });
+    const fields = getValues(name) || [];
+
+    return (
+      <>
+        {fields.map((field, index) => (
+          <Card
+            variant={customField.extra?.border ? 'border' : 'divider'}
+            key={field.id || index}
+          >
+            <Fieldset>
+              <FieldsetLabel>
+                {`${customField.extra?.label.object.title}${!customField.extra?.noIndex ? ' ' + String(index + 1) : ''}`}
+              </FieldsetLabel>
+              <FieldObject
+                name={`${name}.${index}`}
+                error={Array.isArray(error) && error[index]}
+                formState={formState}
+                register={register}
+                control={control}
+                {...customField.extra?.of}
+                Field={Field}
+              />
+              <Button
+                name={`${name}-object-remove`}
+                variant={customField.extra?.label.object?.deleteButtonVariant}
+                type="button"
+                color="warning"
+                onClick={() => remove(index)}
+                disabled={!customField?.editable}
+              >
+                {customField.extra?.label.object?.delete}
+              </Button>
+            </Fieldset>
+          </Card>
+        ))}
+        {customField.editable && (
+          <Button
+            ref={ref}
+            type="button"
+            name={`${name}-add-object`}
+            color="secondary"
+            variant={customField.extra?.label.object?.addButtonVariant}
+            onClick={(ev) => {
+              ev.preventDefault();
+              append({});
+            }}
+            disabled={!customField?.editable}
+          >
+            {customField.extra?.label.object?.add}
+          </Button>
+        )}
+      </>
+    );
+  }
+);
+
+BaseFieldArray.displayName = 'BaseFieldArray';
+
+export default BaseFieldArray;

package/src/FieldArray/FormDialog/ArrayDisplay/ArrayDisplay.stories.js

@@ -0,0 +1,11 @@
+import ArrayDisplay from '@digigov/form/FieldArray/FormDialog/ArrayDisplay';
+
+export default {
+  title: 'Digigov Form/FieldArray/FormDialog/ArrayDisplay',
+  component: ArrayDisplay,
+  displayName: 'ArrayDisplay',
+};
+
+export { Default } from '@digigov/form/FieldArray/FormDialog/ArrayDisplay/__stories__/Default';
+export { Sortable } from '@digigov/form/FieldArray/FormDialog/ArrayDisplay/__stories__/Sortable';
+export { ReadOnly } from '@digigov/form/FieldArray/FormDialog/ArrayDisplay/__stories__/ReadOnly';

package/src/FieldArray/FormDialog/ArrayDisplay/ArrayItemDisplay.tsx

@@ -0,0 +1,165 @@
+import React from 'react';
+import type { UseFieldArrayMove } from 'react-hook-form';
+import { TableDataCell, TableRow } from '@digigov/ui/content';
+import { Button } from '@digigov/ui/form/Button';
+import type { StackProps } from '@digigov/ui/layouts';
+import { Grid, Stack } from '@digigov/ui/layouts';
+import Heading from '@digigov/ui/typography/Heading';
+
+export interface ArrayItemDisplayProps {
+  data: any;
+  name: string;
+  edit: (name: string) => void;
+  remove: (name: string) => void;
+  disabledEdit?: boolean;
+  disabledDelete?: boolean;
+  disabled?: boolean;
+  sortable: boolean;
+  index: number;
+  isFirst: boolean;
+  isLast: boolean;
+  move: UseFieldArrayMove;
+  valueDisplay?: (value) => React.ReactNode;
+  border: boolean;
+  wordBreak?: 'break-all' | 'none';
+  stackProps?: StackProps;
+}
+
+export const ArrayItemDisplay = ({
+  name,
+  data,
+  edit,
+  remove,
+  disabledEdit,
+  disabledDelete,
+  disabled,
+  sortable,
+  index,
+  isFirst,
+  isLast,
+  move,
+  valueDisplay,
+  border = true,
+  wordBreak = 'break-all',
+  stackProps = {
+    spacing: 4,
+    alignItems: 'flex-end',
+    justifyContent: 'flex-end',
+    direction: 'column',
+  },
+}: ArrayItemDisplayProps) => {
+  if (data === undefined || data === null) {
+    return null;
+  }
+  if (
+    Object.keys(data).length === 0 ||
+    (Object.keys(data).length === 1 && data.id)
+  ) {
+    return null;
+  }
+  delete data.id;
+  const values: (string | Record<string, any>)[] =
+    typeof data === 'string' ? [data] : Object.values(data || {});
+  const borderVariant = border === false || sortable ? 'none' : 'border';
+  return (
+    <>
+      <TableRow>
+        {values?.map?.((value, valueIndex) => {
+          return (
+            <TableDataCell
+              key={valueIndex}
+              variant={borderVariant}
+              wordBreak={wordBreak}
+              pb={sortable ? 0 : undefined}
+              pt={sortable ? 4 : undefined}
+            >
+              {sortable && valueIndex === 0 && (
+                <Heading size="sm" className="mb-2">
+                  Επιλογή #{index + 1}
+                </Heading>
+              )}
+              {(value as Record<string, any>)?.name ||
+                (Array.isArray(value)
+                  ? value.join('\n')
+                  : valueDisplay
+                    ? valueDisplay(value)
+                    : value) ||
+                ''}
+            </TableDataCell>
+          );
+        })}
+        {disabled === true ||
+        (disabledEdit === true && disabledDelete === true) ? null : (
+          <TableDataCell variant={borderVariant}>
+            <Stack {...stackProps}>
+              {disabledEdit !== true && (
+                <Button
+                  variant="link"
+                  type="button"
+                  onClick={() => {
+                    edit(name);
+                  }}
+                >
+                  Επεξεργασία
+                </Button>
+              )}
+              {disabledDelete !== true && (
+                <Button
+                  variant="link"
+                  type="button"
+                  onClick={() => remove(name)}
+                >
+                  Διαγραφή
+                </Button>
+              )}
+            </Stack>
+          </TableDataCell>
+        )}
+      </TableRow>
+      {sortable && (
+        <TableRow>
+          <TableDataCell
+            variant={isLast ? 'none' : 'border'}
+            colSpan={
+              disabled === true ||
+              (disabledEdit === true && disabledDelete === true)
+                ? values.length
+                : values.length + 1
+            }
+          >
+            {sortable && !disabled && !(isFirst && isLast) && (
+              <Grid xs={12} mt={2}>
+                Μετακίνηση{' '}
+                {!isFirst && (
+                  <>
+                    προς τα{' '}
+                    <Button
+                      type="button"
+                      variant="link"
+                      onClick={() => move(index, index - 1)}
+                    >
+                      πάνω
+                    </Button>
+                  </>
+                )}
+                {!isFirst && !isLast && ' ή '}
+                {!isLast && (
+                  <>
+                    προς τα{' '}
+                    <Button
+                      type="button"
+                      variant="link"
+                      onClick={() => move(index, index + 1)}
+                    >
+                      κάτω
+                    </Button>
+                  </>
+                )}
+              </Grid>
+            )}
+          </TableDataCell>
+        </TableRow>
+      )}
+    </>
+  );
+};

package/src/FieldArray/FormDialog/ArrayDisplay/ArrayItemHeader.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+import { TableHead, TableHeadCell, TableRow } from '@digigov/ui/content';
+
+export const ArrayItemHeader = ({ labels, disabled }) => {
+  return (
+    <TableHead>
+      <TableRow>
+        {labels.map((label, index) => {
+          return <TableHeadCell key={index}>{label}</TableHeadCell>;
+        })}
+        {!disabled && <TableHeadCell>Ενέργειες</TableHeadCell>}
+      </TableRow>
+    </TableHead>
+  );
+};