@digigov/form 0.10.8 → 0.10.10

package/src/registry.js

@@ -0,0 +1,134 @@
+
+import * as _digigov_form_Field_FieldBase from '@digigov/form/Field/FieldBase';
+import * as _digigov_form_Field_FieldBaseContainer from '@digigov/form/Field/FieldBaseContainer';
+import * as _digigov_form_Field_FieldConditional from '@digigov/form/Field/FieldConditional';
+import * as _digigov_form_Field from '@digigov/form/Field';
+import * as _digigov_form_Field_types from '@digigov/form/Field/types';
+import * as _digigov_form_Field_utils from '@digigov/form/Field/utils';
+import * as _digigov_form_FieldArray from '@digigov/form/FieldArray';
+import * as _digigov_form_FieldObject from '@digigov/form/FieldObject';
+import * as _digigov_form_Fieldset_FieldsetWithContext from '@digigov/form/Fieldset/FieldsetWithContext';
+import * as _digigov_form_Fieldset from '@digigov/form/Fieldset';
+import * as _digigov_form_Fieldset_types from '@digigov/form/Fieldset/types';
+import * as _digigov_form_FormBuilder_FormBuilder from '@digigov/form/FormBuilder/FormBuilder';
+import * as _digigov_form_FormBuilder from '@digigov/form/FormBuilder';
+import * as _digigov_form_FormContext from '@digigov/form/FormContext';
+import * as _digigov_form from '@digigov/form';
+import * as _digigov_form_inputs_AutoComplete from '@digigov/form/inputs/AutoComplete';
+import * as _digigov_form_inputs_Checkboxes from '@digigov/form/inputs/Checkboxes';
+import * as _digigov_form_inputs_DateInput from '@digigov/form/inputs/DateInput';
+import * as _digigov_form_inputs_FileInput from '@digigov/form/inputs/FileInput';
+import * as _digigov_form_inputs from '@digigov/form/inputs';
+import * as _digigov_form_inputs_Input from '@digigov/form/inputs/Input';
+import * as _digigov_form_inputs_Label from '@digigov/form/inputs/Label';
+import * as _digigov_form_inputs_Radio from '@digigov/form/inputs/Radio';
+import * as _digigov_form_inputs_Select from '@digigov/form/inputs/Select';
+import * as _digigov_form_internal from '@digigov/form/internal';
+import * as _digigov_form_MultiplicityField_add_objects from '@digigov/form/MultiplicityField/add-objects';
+import * as _digigov_form_MultiplicityField from '@digigov/form/MultiplicityField';
+import * as _digigov_form_Questions_getNextStep from '@digigov/form/Questions/getNextStep';
+import * as _digigov_form_Questions from '@digigov/form/Questions';
+import * as _digigov_form_Questions_Questions from '@digigov/form/Questions/Questions';
+import * as _digigov_form_Questions_QuestionsContext from '@digigov/form/Questions/QuestionsContext';
+import * as _digigov_form_Questions_Step_getAddMoreFields from '@digigov/form/Questions/Step/getAddMoreFields';
+import * as _digigov_form_Questions_Step from '@digigov/form/Questions/Step';
+import * as _digigov_form_Questions_Step_ReviewStep from '@digigov/form/Questions/Step/ReviewStep';
+import * as _digigov_form_Questions_Step_Step from '@digigov/form/Questions/Step/Step';
+import * as _digigov_form_Questions_Step_StepArrayReview from '@digigov/form/Questions/Step/StepArrayReview';
+import * as _digigov_form_Questions_Step_StepContext from '@digigov/form/Questions/Step/StepContext';
+import * as _digigov_form_Questions_Step_StepDescription from '@digigov/form/Questions/Step/StepDescription';
+import * as _digigov_form_Questions_Step_StepForm from '@digigov/form/Questions/Step/StepForm';
+import * as _digigov_form_Questions_Step_StepQuote from '@digigov/form/Questions/Step/StepQuote';
+import * as _digigov_form_Questions_Step_StepTitle from '@digigov/form/Questions/Step/StepTitle';
+import * as _digigov_form_Questions_Step_types from '@digigov/form/Questions/Step/types';
+import * as _digigov_form_Questions_types from '@digigov/form/Questions/types';
+import * as _digigov_form_types from '@digigov/form/types';
+import * as _digigov_form_utils from '@digigov/form/utils';
+import * as _digigov_form_validators from '@digigov/form/validators';
+import * as _digigov_form_validators_types from '@digigov/form/validators/types';
+import * as _digigov_form_validators_utils_afm from '@digigov/form/validators/utils/afm';
+import * as _digigov_form_validators_utils_file from '@digigov/form/validators/utils/file';
+import * as _digigov_form_validators_utils_iban from '@digigov/form/validators/utils/iban';
+import * as _digigov_form_validators_utils from '@digigov/form/validators/utils';
+import * as _digigov_form_validators_utils_int from '@digigov/form/validators/utils/int';
+import * as _digigov_form_validators_utils_number from '@digigov/form/validators/utils/number';
+import * as _digigov_form_validators_utils_phone from '@digigov/form/validators/utils/phone';
+import * as _digigov_form_validators_utils_postal_code from '@digigov/form/validators/utils/postal_code';
+import * as _digigov_form_validators_utils_uuid4 from '@digigov/form/validators/utils/uuid4'
+function lazyImport(pkgImport) {
+  return new Proxy(
+    {},
+    {
+      get: (_target, name) => {
+        if (name === '__esModule' || name === 'default') {
+          return pkgImport.default;
+        } else if(
+          name === '*'
+        ) {
+          return pkgImport;
+        } else {
+          return pkgImport[name];
+        }
+      },
+    }
+  )
+}
+export default {
+  '@digigov/form/Field/FieldBase': lazyImport(_digigov_form_Field_FieldBase),
+  '@digigov/form/Field/FieldBaseContainer': lazyImport(_digigov_form_Field_FieldBaseContainer),
+  '@digigov/form/Field/FieldConditional': lazyImport(_digigov_form_Field_FieldConditional),
+  '@digigov/form/Field': lazyImport(_digigov_form_Field),
+  '@digigov/form/Field/types': lazyImport(_digigov_form_Field_types),
+  '@digigov/form/Field/utils': lazyImport(_digigov_form_Field_utils),
+  '@digigov/form/FieldArray': lazyImport(_digigov_form_FieldArray),
+  '@digigov/form/FieldObject': lazyImport(_digigov_form_FieldObject),
+  '@digigov/form/Fieldset/FieldsetWithContext': lazyImport(_digigov_form_Fieldset_FieldsetWithContext),
+  '@digigov/form/Fieldset': lazyImport(_digigov_form_Fieldset),
+  '@digigov/form/Fieldset/types': lazyImport(_digigov_form_Fieldset_types),
+  '@digigov/form/FormBuilder/FormBuilder': lazyImport(_digigov_form_FormBuilder_FormBuilder),
+  '@digigov/form/FormBuilder': lazyImport(_digigov_form_FormBuilder),
+  '@digigov/form/FormContext': lazyImport(_digigov_form_FormContext),
+  '@digigov/form': lazyImport(_digigov_form),
+  '@digigov/form/inputs/AutoComplete': lazyImport(_digigov_form_inputs_AutoComplete),
+  '@digigov/form/inputs/Checkboxes': lazyImport(_digigov_form_inputs_Checkboxes),
+  '@digigov/form/inputs/DateInput': lazyImport(_digigov_form_inputs_DateInput),
+  '@digigov/form/inputs/FileInput': lazyImport(_digigov_form_inputs_FileInput),
+  '@digigov/form/inputs': lazyImport(_digigov_form_inputs),
+  '@digigov/form/inputs/Input': lazyImport(_digigov_form_inputs_Input),
+  '@digigov/form/inputs/Label': lazyImport(_digigov_form_inputs_Label),
+  '@digigov/form/inputs/Radio': lazyImport(_digigov_form_inputs_Radio),
+  '@digigov/form/inputs/Select': lazyImport(_digigov_form_inputs_Select),
+  '@digigov/form/internal': lazyImport(_digigov_form_internal),
+  '@digigov/form/MultiplicityField/add-objects': lazyImport(_digigov_form_MultiplicityField_add_objects),
+  '@digigov/form/MultiplicityField': lazyImport(_digigov_form_MultiplicityField),
+  '@digigov/form/Questions/getNextStep': lazyImport(_digigov_form_Questions_getNextStep),
+  '@digigov/form/Questions': lazyImport(_digigov_form_Questions),
+  '@digigov/form/Questions/Questions': lazyImport(_digigov_form_Questions_Questions),
+  '@digigov/form/Questions/QuestionsContext': lazyImport(_digigov_form_Questions_QuestionsContext),
+  '@digigov/form/Questions/Step/getAddMoreFields': lazyImport(_digigov_form_Questions_Step_getAddMoreFields),
+  '@digigov/form/Questions/Step': lazyImport(_digigov_form_Questions_Step),
+  '@digigov/form/Questions/Step/ReviewStep': lazyImport(_digigov_form_Questions_Step_ReviewStep),
+  '@digigov/form/Questions/Step/Step': lazyImport(_digigov_form_Questions_Step_Step),
+  '@digigov/form/Questions/Step/StepArrayReview': lazyImport(_digigov_form_Questions_Step_StepArrayReview),
+  '@digigov/form/Questions/Step/StepContext': lazyImport(_digigov_form_Questions_Step_StepContext),
+  '@digigov/form/Questions/Step/StepDescription': lazyImport(_digigov_form_Questions_Step_StepDescription),
+  '@digigov/form/Questions/Step/StepForm': lazyImport(_digigov_form_Questions_Step_StepForm),
+  '@digigov/form/Questions/Step/StepQuote': lazyImport(_digigov_form_Questions_Step_StepQuote),
+  '@digigov/form/Questions/Step/StepTitle': lazyImport(_digigov_form_Questions_Step_StepTitle),
+  '@digigov/form/Questions/Step/types': lazyImport(_digigov_form_Questions_Step_types),
+  '@digigov/form/Questions/types': lazyImport(_digigov_form_Questions_types),
+  '@digigov/form/types': lazyImport(_digigov_form_types),
+  '@digigov/form/utils': lazyImport(_digigov_form_utils),
+  '@digigov/form/validators': lazyImport(_digigov_form_validators),
+  '@digigov/form/validators/types': lazyImport(_digigov_form_validators_types),
+  '@digigov/form/validators/utils/afm': lazyImport(_digigov_form_validators_utils_afm),
+  '@digigov/form/validators/utils/file': lazyImport(_digigov_form_validators_utils_file),
+  '@digigov/form/validators/utils/iban': lazyImport(_digigov_form_validators_utils_iban),
+  '@digigov/form/validators/utils': lazyImport(_digigov_form_validators_utils),
+  '@digigov/form/validators/utils/int': lazyImport(_digigov_form_validators_utils_int),
+  '@digigov/form/validators/utils/number': lazyImport(_digigov_form_validators_utils_number),
+  '@digigov/form/validators/utils/phone': lazyImport(_digigov_form_validators_utils_phone),
+  '@digigov/form/validators/utils/postal_code': lazyImport(_digigov_form_validators_utils_postal_code),
+  '@digigov/form/validators/utils/uuid4': lazyImport(_digigov_form_validators_utils_uuid4)
+};
+  

package/src/types.tsx

@@ -0,0 +1,110 @@
+import { UseFormReturn, UseFormProps } from 'react-hook-form';
+import { GridProps } from '@digigov/ui/layouts/Grid';
+import { ValidatorSchema } from '@digigov/form/validators/types';
+import { FieldComponentRegistry } from '@digigov/form/Field/types';
+
+export type FieldError = {
+  message: string;
+};
+
+export type FieldLabelProps = {
+  primary?: string;
+  secondary?: string;
+};
+
+export interface FieldCondition {
+  is: string;
+  then?: Partial<FieldSpec>;
+  else?: Partial<FieldSpec>;
+}
+export interface FieldSpec {
+  key: string; // !TODO rename key to name;
+  type?:
+    | 'int'
+    | 'string'
+    | 'text'
+    | 'boolean'
+    | 'email'
+    | 'uuid4'
+    | 'choice:multiple'
+    | 'choice:single'
+    | 'mobile_phone'
+    | 'date'
+    | 'afm'
+    | 'iban'
+    | 'file'
+    | 'postal_code'
+    | 'phone_number'
+    | 'array'
+    | 'object';
+  component?: any;
+  condition?: Record<string, FieldCondition>;
+  controlled?: boolean;
+  label?: FieldLabelProps;
+  extra?: Record<string, any>;
+  editable?: boolean;
+  required?: boolean;
+  enabled?: boolean;
+  layout?: Record<
+    string,
+    | GridProps['xs']
+    | GridProps['sm']
+    | GridProps['md']
+    | GridProps['lg']
+    | GridProps['xl']
+  >;
+  validators?: ValidatorSchema[];
+  wrapper?: 'label' | 'fieldset';
+}
+
+export interface FieldsetSpec {
+  key: string;
+  fields: string[];
+  label?: FieldLabelProps;
+  body?: React.ReactNode;
+}
+
+export type FormData = UseFormProps['defaultValues'];
+
+export interface FormContextProps {
+  fieldsetsMap?: Record<string, FieldsetSpec>;
+  fieldsMap: Record<string, FieldSpec>;
+  control: UseFormReturn['control'];
+  register: UseFormReturn['register'];
+  trigger: UseFormReturn['trigger'];
+  clearErrors: UseFormReturn['clearErrors'];
+  watch: UseFormReturn['watch'];
+  getFieldState: UseFormReturn['getFieldState'];
+  setValue: UseFormReturn['setValue'];
+  getValues: UseFormReturn['getValues'];
+  unregister: UseFormReturn['unregister'];
+  formState: UseFormReturn['formState'];
+  reset: UseFormReturn['reset'];
+  registerField: (field: FieldSpec) => void;
+  errors: UseFormReturn['formState']['errors'];
+  componentRegistry?: FieldComponentRegistry;
+}
+
+export interface FormBuilderProps {
+  fields?: FieldSpec[];
+  fieldsets?: FieldsetSpec[];
+  initial?: FormData;
+  onSubmit?: (data: FormData) => void | null | FieldError[];
+  mode?: UseFormProps['mode'];
+  reValidateMode?: UseFormProps['reValidateMode'];
+  criteriaMode?: UseFormProps['criteriaMode'];
+  children?: React.ReactNode;
+  shouldFocusError?: boolean;
+  auto?: boolean;
+  validatorRegistry?: Record<string, ValidatorSchema[]>;
+  componentRegistry?: FieldComponentRegistry;
+  grid?: boolean;
+}
+
+export interface FormBaseProps
+  extends Omit<FormBuilderProps, 'fields' | 'fieldsets' | 'auto'> {
+  fieldsetsMap?: Record<string, FieldsetSpec>;
+  fieldsMap: Record<string, FieldSpec>;
+  registerField: (field: FieldSpec) => void;
+  resolver: any;
+}

package/src/utils.ts

@@ -0,0 +1,78 @@
+import * as Yup from 'yup';
+import { validateFieldsNatively } from '@hookform/resolvers';
+import { appendErrors, FieldError } from 'react-hook-form';
+
+/**
+ * Why `path!` ? because it could be `undefined` in some case
+ * https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string
+ */
+const parseErrorSchema = (
+  error: Yup.ValidationError,
+  validateAllFieldCriteria: boolean
+) => {
+  return (error.inner || []).reduce<Record<string, FieldError>>(
+    (previous, error) => {
+      error.path = error.path?.replace(/\[([0-9]+)\]/g, '.$1');
+      if (!previous[error.path!]) {
+        previous[error.path!] = { message: error.message, type: error.type! };
+      }
+
+      if (validateAllFieldCriteria) {
+        const types = previous[error.path!].types;
+        const messages = types && types[error.type!];
+
+        previous[error.path!] = appendErrors(
+          error.path!,
+          validateAllFieldCriteria,
+          previous,
+          error.type!,
+          messages
+            ? ([] as string[]).concat(messages as string[], error.message)
+            : error.message
+        ) as FieldError;
+      }
+
+      return previous;
+    },
+    {}
+  );
+};
+
+export const yupResolver = (
+  schema: any,
+  schemaOptions: any = {},
+  resolverOptions: any = {}
+) => async (values, context, options) => {
+  try {
+    if (schemaOptions.context && process.env.NODE_ENV === 'development') {
+      // eslint-disable-next-line no-console
+      console.warn(
+        "You should not used the yup options context. Please, use the 'useForm' context object instead"
+      );
+    }
+
+    const result = await schema[
+      resolverOptions.mode === 'sync' ? 'validateSync' : 'validate'
+    ](values, Object.assign({ abortEarly: false }, schemaOptions, { context }));
+
+    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+
+    return {
+      values: resolverOptions.rawValues ? values : result,
+      errors: {},
+    };
+  } catch (e) {
+    if (!e.inner) {
+      throw e;
+    }
+
+    const parsed = parseErrorSchema(
+      e,
+      !options.shouldUseNativeValidation && options.criteriaMode === 'all'
+    );
+    return {
+      values: {},
+      errors: parsed,
+    };
+  }
+};

package/src/validators/index.ts

@@ -0,0 +1,203 @@
+import * as yup from 'yup';
+import { FieldSpec } from '@digigov/form/types';
+import { ValidatorSchema } from '@digigov/form/validators/types';
+import { MutableRefObject, useMemo } from 'react';
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import {
+  getYupObjectShape,
+  AFM_VALIDATOR,
+  FILE_MAX_SIZE_VALIDATOR,
+  IBAN_VALIDATOR,
+  MOBILE_PHONE_VALIDATOR,
+  PHONE_NUMBER_VALIDATOR,
+  POSTALCODE_VALIDATOR,
+  UUID4_VALIDATOR,
+} from '@digigov/form/validators/utils';
+import { MixedSchema } from 'yup/lib/mixed';
+import { RequiredArraySchema } from 'yup/lib/array';
+import { AnyObject } from 'yup/lib/types';
+import Lazy from 'yup/lib/Lazy';
+import { TypeOfShape, AssertsShape } from 'yup/lib/object';
+import { AnyObjectSchema, StringSchema } from 'yup';
+import { NUMBER_VALIDATOR } from '@digigov/form/validators/utils/number';
+import { INT_VALIDATOR } from '@digigov/form/validators/utils/int';
+dayjs.extend(customParseFormat);
+
+const VALID_DATE_FORMATS = ['DD/MM/YYYY'];
+const DATE_CACHE = {};
+const getDate = (v) => {
+  return DATE_CACHE[v] ? DATE_CACHE[v] : dayjs(v, VALID_DATE_FORMATS, true);
+};
+
+export const getYUPTypeMap = (): Record<string, any> => {
+  const yupTypeMap = {
+    file: (field): MixedSchema => {
+      return yup
+        .mixed()
+        .transform((value) => {
+          if (!value.length) {
+            return null;
+          }
+          return value;
+        })
+        .nullable()
+        .test(FILE_MAX_SIZE_VALIDATOR(field));
+    },
+    string: yup.string,
+    text: yup.string,
+    boolean: yup.boolean,
+    object: (
+      field
+    ):
+      | yup.ObjectSchema<any, AnyObject, TypeOfShape<any>, AssertsShape<any>>
+      | Lazy<any, unknown> => {
+      return getYupObjectShape(field.extra.fields, yupTypeMap);
+    },
+    array: (
+      field
+    ):
+      | yup.ArraySchema<any, AnyObject, any[] | undefined>
+      | RequiredArraySchema<any, AnyObject, any[] | undefined> => {
+      if (typeof field.extra.of === 'object') {
+        // else if the field is an object then it is a scalar type
+        // eg. number, string etc.
+        let arrayValidator = yup
+          .array()
+          .of(yupTypeMap[field.extra.of.type](field.extra.of))
+          .required(field.required);
+        if (field.extra.length)
+          arrayValidator = arrayValidator.length(field.extra.length, {
+            key: 'form.error.array.length',
+            context: {
+              length: field.extra.length,
+            },
+          });
+        if (field.extra.min)
+          arrayValidator = arrayValidator.min(field.extra.min, {
+            key: 'form.error.array.min',
+            context: {
+              min: field.extra.min,
+            },
+          });
+        if (field.extra.max)
+          arrayValidator = arrayValidator.max(field.extra.max, {
+            key: 'form.error.array.max',
+            context: {
+              max: field.extra.max,
+            },
+          });
+        return arrayValidator;
+      } else if (typeof field.extra.of === 'string') {
+        return yup.array().of(yupTypeMap[field.extra.of]());
+      } else {
+        // in any other case it will be string
+        return yup.array().of(yup.string());
+      }
+    },
+    int: (): MixedSchema =>
+      yup
+        .mixed()
+        .transform((_, val) => (val !== '' ? Number(val) : null))
+        .test(NUMBER_VALIDATOR())
+        .test(INT_VALIDATOR()),
+    email: (): yup.StringSchema => yup.string().email('form.error.email'),
+    afm: (): yup.StringSchema => yup.string().test(AFM_VALIDATOR),
+    uuid4: (): yup.StringSchema => yup.string().test(UUID4_VALIDATOR),
+    iban: (field): yup.StringSchema => yup.string().test(IBAN_VALIDATOR(field)),
+    postal_code: (field): yup.StringSchema =>
+      yup.string().test(POSTALCODE_VALIDATOR(field)),
+    mobile_phone: (): yup.StringSchema =>
+      yup.string().test(MOBILE_PHONE_VALIDATOR),
+    phone_number: (field): yup.StringSchema =>
+      yup.string().test(PHONE_NUMBER_VALIDATOR(field)),
+    'choice:multiple': (): yup.ArraySchema<
+      yup.StringSchema<string | undefined, AnyObject, string | undefined>,
+      AnyObject,
+      (string | undefined)[] | null | undefined,
+      (string | undefined)[] | null | undefined
+    > => yup.array().of(yup.string()).nullable(),
+    'choice:single': (): StringSchema<
+      string | null | undefined,
+      AnyObject,
+      string | null | undefined
+    > => yup.string().nullable(),
+    date: (field) => {
+      let simpleDate = yup
+        .string()
+        .nullable(true)
+        .test('date', 'form.error.date.invalid', function (value) {
+          if (!value) return true;
+          const date = getDate(value);
+          return date.isValid();
+        });
+      const params = field.extra || {};
+      if (params.max) {
+        let maxDate;
+        if (params.max === 'now') {
+          const today = new Date();
+          maxDate = new Date(today);
+        } else {
+          maxDate = getDate(params.max).toDate();
+        }
+        const maxNextDate = new Date(maxDate);
+        maxNextDate.setDate(maxDate.getDate() + 1);
+        simpleDate = simpleDate.test({
+          name: 'earlier-than',
+          message: {
+            key: 'form.error.date.earlier_than',
+            context: {
+              maxDate: maxNextDate.toLocaleDateString(),
+            },
+          },
+          test: function (value) {
+            if (!value) return true;
+            const date = getDate(value);
+            const isValid = +date.toDate() < +maxDate;
+            return isValid;
+          },
+        });
+      }
+      if (params.min) {
+        let minDate;
+        if (params.min === 'now') {
+          const today = new Date();
+          minDate = new Date(today);
+        } else {
+          minDate = getDate(params.min).toDate();
+        }
+        const minPreviousDate = new Date(minDate);
+        minPreviousDate.setDate(minDate.getDate() - 1);
+        simpleDate = simpleDate.test({
+          name: 'later-than',
+          message: {
+            key: 'form.error.date.later_than',
+            context: {
+              minDate: minPreviousDate.toLocaleDateString(),
+            },
+          },
+          test: function (value) {
+            if (!value) return true;
+            const date = getDate(value);
+            const isValid = +date.toDate() > +minDate;
+            return isValid;
+          },
+        });
+      }
+      return simpleDate;
+    },
+  };
+  return yupTypeMap;
+};
+
+export interface MutableRefObjectProps {}
+// Create a yup validation schema from given fields input
+export function useValidationSchema(
+  fields: FieldSpec[] | MutableRefObject<MutableRefObjectProps>,
+  validatorRegistry?: Record<string, ValidatorSchema[]>
+): Lazy<any, unknown> | AnyObjectSchema | void {
+  return useMemo(() => {
+    const yupTypeMap = getYUPTypeMap();
+    return getYupObjectShape(fields, yupTypeMap, validatorRegistry);
+  }, []);
+}

package/src/validators/types.ts

@@ -0,0 +1,2 @@
+import * as yup from 'yup';
+export type ValidatorSchema = yup.TestConfig;

package/src/validators/utils/afm.ts

@@ -0,0 +1,37 @@
+export function validateAFM(afm: string): boolean {
+  if (afm.length !== 9) {
+    // "afm should be 9 digits"
+    return false;
+  }
+
+  if (!/^\d+$/.test(afm)) {
+    // "This is not a number"
+    return false;
+  }
+
+  if (afm === '0'.repeat(9)) {
+    // "This is zero number (000000000)"
+    return false;
+  }
+
+  const sum = afm
+    .substring(0, 8)
+    .split('')
+    .reduce((s, v, i) => s + (parseInt(v) << (8 - i)), 0);
+
+  const calc = sum % 11;
+  const d9 = parseInt(afm[8]);
+  const valid = calc % 10 === d9;
+  return valid;
+}
+
+export const AFM_VALIDATOR = {
+  name: 'afm-validator',
+  message: 'form.error.afm',
+  test: (value): boolean => {
+    if (value) {
+      return validateAFM(value);
+    }
+    return true;
+  },
+};

package/src/validators/utils/file.ts

@@ -0,0 +1,25 @@
+import { ValidatorSchema } from '@digigov/form/validators/types';
+import { FieldSpec } from '@digigov/form/types';
+
+const DEFAULT_FILE_MAX_SIZE = 10000000;
+
+export const FILE_MAX_SIZE_VALIDATOR = (field: FieldSpec): ValidatorSchema => ({
+  name: 'file-max-size-validator',
+  message: 'form.error.file_size',
+  test: (value: File[]): boolean => {
+    if (field.extra && field.extra.maxSize && value) {
+      for (const file of value) {
+        if (file.size >= field.extra.maxSize) {
+          return false;
+        }
+      }
+    } else if (value) {
+      for (const file of value) {
+        if (file.size >= DEFAULT_FILE_MAX_SIZE) {
+          return false;
+        }
+      }
+    }
+    return true;
+  },
+});