@digigov/form 2.0.0-264e5fff → 2.0.0-290ada95

package/src/inputs/Radio/doc.mdx

@@ -10,14 +10,14 @@ Radios are used to let a user select one option of a limited number of choices.
 
 ### Default
 
-<code src="@digigov/form/inputs/Radio/__stories__/Default.tsx" />
+<code src="@digigov/form/src/inputs/Radio/__stories__/Default.tsx" />
 
 
 ### Conditional
 
-<code src="@digigov/form/inputs/Radio/__stories__/Conditional.tsx" />
+<code src="@digigov/form/src/inputs/Radio/__stories__/Conditional.tsx" />
 
 
 ### With divider
 
-<code src="@digigov/form/inputs/Radio/__stories__/WithDivider.tsx" />
+<code src="@digigov/form/src/inputs/Radio/__stories__/WithDivider.tsx" />

package/src/inputs/Select/doc.mdx

@@ -10,4 +10,4 @@ The select element represents a control that provides a menu of options.
 
 ### Default
 
-<code src="@digigov/form/inputs/Select/__stories__/Default.tsx" />
+<code src="@digigov/form/src/inputs/Select/__stories__/Default.tsx" />

package/{lazy/index.js → src/lazy.ts}

@@ -42,38 +42,13 @@ export default {
   'Input': lazy(() => import('@digigov/form/inputs/Input').then((module) => ({ default: module['Input'] }))),
   'Radio': lazy(() => import('@digigov/form/inputs').then((module) => ({ default: module['Radio'] }))),
   'Select': lazy(() => import('@digigov/form/inputs/Select').then((module) => ({ default: module['Select'] }))),
-  'FIELD_COMPONENTS': lazy(() => import('@digigov/form/inputs/registry').then((module) => ({ default: module['FIELD_COMPONENTS'] }))),
-  'ALTERNATIVE_COMPONENTS': lazy(() => import('@digigov/form/inputs/registry').then((module) => ({ default: module['ALTERNATIVE_COMPONENTS'] }))),
-  'CONTROLLED_FIELD_COMPONENTS': lazy(() => import('@digigov/form/inputs/registry').then((module) => ({ default: module['CONTROLLED_FIELD_COMPONENTS'] }))),
   'ArrayEditModal': lazy(() => import('@digigov/form/FieldArray/FormDialog/ArrayEditModal').then((module) => ({ default: module['ArrayEditModal'] }))),
   'FormDialog': lazy(() => import('@digigov/form/FieldArray/FormDialog').then((module) => ({ default: module['FormDialog'] }))),
   'AutoCompleteInput': lazy(() => import('@digigov/form/inputs/AutoCompleteInput').then((module) => ({ default: module['AutoCompleteInput'] }))),
   'DateTimeInput': lazy(() => import('@digigov/form/inputs/DateTimeInput').then((module) => ({ default: module['DateTimeInput'] }))),
   'Image': lazy(() => import('@digigov/form/inputs/ImageInput').then((module) => ({ default: module['Image'] }))),
-  'RE_DIGIT': lazy(() => import('@digigov/form/inputs/OtpInput').then((module) => ({ default: module['RE_DIGIT'] }))),
-  'REMOVE_SPACES': lazy(() => import('@digigov/form/inputs/OtpInput').then((module) => ({ default: module['REMOVE_SPACES'] }))),
   'RadioButtonsGroup': lazy(() => import('@digigov/form/inputs/Radio').then((module) => ({ default: module['RadioButtonsGroup'] }))),
   'ControlledRadioButtonsGroup': lazy(() => import('@digigov/form/inputs/Radio').then((module) => ({ default: module['ControlledRadioButtonsGroup'] }))),
-  'AFM_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['AFM_VALIDATOR'] }))),
-  'AMKA_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['AMKA_VALIDATOR'] }))),
-  'LATER_THAN_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['LATER_THAN_VALIDATOR'] }))),
-  'EARLIER_THAN_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['EARLIER_THAN_VALIDATOR'] }))),
-  'DATE_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['DATE_VALIDATOR'] }))),
-  'LATER_THAN_DATETIME_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['LATER_THAN_DATETIME_VALIDATOR'] }))),
-  'EARLIER_THAN_DATETIME_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['EARLIER_THAN_DATETIME_VALIDATOR'] }))),
-  'DATETIME_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['DATETIME_VALIDATOR'] }))),
-  'EMAIL_VALIDATOR': lazy(() => import('@digigov/form/validators/utils/email').then((module) => ({ default: module['EMAIL_VALIDATOR'] }))),
-  'FILE_MAX_SIZE_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['FILE_MAX_SIZE_VALIDATOR'] }))),
-  'IBAN_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['IBAN_VALIDATOR'] }))),
-  'IMAGE_DIMENSION_VALIDATOR': lazy(() => import('@digigov/form/validators/utils').then((module) => ({ default: module['IMAGE_DIMENSION_VALIDATOR'] }))),
-  'OTP_VALIDATOR': lazy(() => import('@digigov/form/validators/utils/otp').then((module) => ({ default: module['OTP_VALIDATOR'] }))),
-  'MOBILE_PHONE_VALIDATOR': lazy(() => import('@digigov/form/validators/utils/phone').then((module) => ({ default: module['MOBILE_PHONE_VALIDATOR'] }))),
-  'PHONE_NUMBER_VALIDATOR': lazy(() => import('@digigov/form/validators/utils/phone').then((module) => ({ default: module['PHONE_NUMBER_VALIDATOR'] }))),
-  'POSTALCODE_VALIDATOR': lazy(() => import('@digigov/form/validators/utils/postal_code').then((module) => ({ default: module['POSTALCODE_VALIDATOR'] }))),
-  'UUID4_VALIDATOR': lazy(() => import('@digigov/form/validators/utils/uuid4').then((module) => ({ default: module['UUID4_VALIDATOR'] }))),
-  'TEXT_LIMIT_VALIDATOR': lazy(() => import('@digigov/form/validators/utils/text_limit').then((module) => ({ default: module['TEXT_LIMIT_VALIDATOR'] }))),
-  'INT_VALIDATOR': lazy(() => import('@digigov/form/validators/utils/int').then((module) => ({ default: module['INT_VALIDATOR'] }))),
-  'NUMBER_VALIDATOR': lazy(() => import('@digigov/form/validators/utils/number').then((module) => ({ default: module['NUMBER_VALIDATOR'] }))),
   'ArrayContainerDisplay': lazy(() => import('@digigov/form/FieldArray/FormDialog/ArrayDisplay/ArrayContainerDisplay').then((module) => ({ default: module['ArrayContainerDisplay'] }))),
   'ArrayItemDisplay': lazy(() => import('@digigov/form/FieldArray/FormDialog/ArrayDisplay/ArrayItemDisplay').then((module) => ({ default: module['ArrayItemDisplay'] }))),
   'ArrayItemHeader': lazy(() => import('@digigov/form/FieldArray/FormDialog/ArrayDisplay/ArrayItemHeader').then((module) => ({ default: module['ArrayItemHeader'] }))),

package/types.d.ts

@@ -1,8 +1,8 @@
 import type { UseFormReturn, UseFormProps, ErrorOption } from 'react-hook-form';
-import type { FieldLabelProps, FieldSpec, FormData } from '@digigov/form/Field/types';
-import type { FieldComponentRegistry } from '@digigov/form/inputs/registry';
-import type { ValidatorSchema } from '@digigov/form/validators/types';
-export * from '@digigov/form/Field/types';
+import type { FieldLabelProps, FieldSpec, FormData } from './Field/types.js';
+import type { FieldComponentRegistry } from './inputs/registry.js';
+import type { ValidatorSchema } from './validators/types.js';
+export * from './Field/types.js';
 export interface FieldError {
     message: string;
 }

package/types.js

@@ -0,0 +1 @@
+export * from "./Field/types.js";

package/utils.js

@@ -0,0 +1,56 @@
+import { validateFieldsNatively } from "@hookform/resolvers";
+import { appendErrors } from "react-hook-form";
+const parseErrorSchema = (error, validateAllFieldCriteria)=>(error.inner || []).reduce((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 ? [].concat(messages, error.message) : error.message);
+        }
+        return previous;
+    }, {});
+function isPlainObject(obj) {
+    return 'object' == typeof obj && null !== obj && '[object Object]' === Object.prototype.toString.call(obj);
+}
+function flattenObject(obj, prefix = '') {
+    return Object.keys(obj).reduce((acc, key)=>{
+        const prefixedKey = prefix ? `${prefix}.${key}` : key;
+        if (isPlainObject(obj[key])) Object.assign(acc, flattenObject(obj[key], prefixedKey));
+        else acc[prefixedKey] = obj[key];
+        return acc;
+    }, {});
+}
+const yupResolver = (schema, schemaOptions = {}, resolverOptions = {})=>async (values, context, options)=>{
+        try {
+            if (schemaOptions.context && 'development' === process.env.NODE_ENV) console.warn("You should not used the yup options context. Please, use the 'useForm' context object instead");
+            const result = await schema['sync' === resolverOptions.mode ? 'validateSync' : 'validate'](flattenObject(values), Object.assign({
+                abortEarly: false
+            }, schemaOptions, {
+                context
+            }));
+            if (options.shouldUseNativeValidation) validateFieldsNatively({}, options);
+            return {
+                values: resolverOptions.rawValues ? values : result,
+                errors: {}
+            };
+        } catch (e) {
+            if (!e.inner) throw e;
+            return {
+                values: {},
+                errors: parseErrorSchema(e, !options.shouldUseNativeValidation && 'all' === options.criteriaMode),
+                options
+            };
+        }
+    };
+function omit(obj, keys) {
+    const result = {
+        ...obj
+    };
+    for (const key of keys)delete result[key];
+    return result;
+}
+export { omit, yupResolver };

package/validators/index.d.ts

@@ -1,8 +1,8 @@
 import type { MutableRefObject } from 'react';
 import type { AnyObjectSchema } from 'yup';
 import type Lazy from 'yup/lib/Lazy';
-import type { FieldSpec } from '@digigov/form/types';
-import type { ValidatorSchema } from '@digigov/form/validators/types';
+import type { FieldSpec } from '../types.js';
+import type { ValidatorSchema } from './types.js';
 export declare const getYUPTypeMap: (validatorRegistry?: Record<string, any>) => Record<string, any>;
 export interface MutableRefObjectProps {
 }

package/validators/index.js

@@ -1,164 +1,117 @@
 import { useMemo } from "react";
-import * as yup from "yup";
-import {
-  getYupObjectShape,
-  AFM_VALIDATOR,
-  AMKA_VALIDATOR,
-  FILE_MAX_SIZE_VALIDATOR,
-  IBAN_VALIDATOR,
-  OTP_VALIDATOR,
-  MOBILE_PHONE_VALIDATOR,
-  PHONE_NUMBER_VALIDATOR,
-  TEXT_LIMIT_VALIDATOR,
-  POSTALCODE_VALIDATOR,
-  UUID4_VALIDATOR,
-  IMAGE_DIMENSION_VALIDATOR,
-  DATE_VALIDATOR,
-  LATER_THAN_VALIDATOR,
-  EARLIER_THAN_VALIDATOR,
-  DATETIME_VALIDATOR,
-  LATER_THAN_DATETIME_VALIDATOR,
-  EARLIER_THAN_DATETIME_VALIDATOR
-} from "@digigov/form/validators/utils";
-import { EMAIL_VALIDATOR } from "@digigov/form/validators/utils/email";
-import { INT_VALIDATOR } from "@digigov/form/validators/utils/int";
-import { NUMBER_VALIDATOR } from "@digigov/form/validators/utils/number";
-const getYUPTypeMap = (validatorRegistry) => {
-  const yupTypeMap = {
-    file: (field) => {
-      return yup.mixed().transform((value) => {
-        if (!value || value.length === 0) {
-          return null;
-        }
-        return value;
-      }).nullable().test(FILE_MAX_SIZE_VALIDATOR(field));
-    },
-    string: (field) => {
-      if (field.trim) {
-        return yup.string().trim();
-      } else {
-        return yup.string();
-      }
-    },
-    boolean: () => {
-      return yup.boolean().nullable().transform((value) => {
-        if (value === "" || typeof value === "string") return null;
-        if (typeof value === "boolean") return value;
-        if (value === 0 || value === 1) return Boolean(value);
-        return value;
-      });
-    },
-    object: (field) => {
-      return getYupObjectShape(field.extra.fields, yupTypeMap);
-    },
-    rate: (field) => {
-      const min = field?.min ? field.min : 0;
-      const max = field?.max ? field.max : 100;
-      return yup.number().transform((v, o) => o === "" ? null : v).nullable().notRequired().integer({ key: "form.error.positive_integer_number" }).min(min, {
-        key: "form.error.rate.rate_percent",
-        context: { min, max }
-      }).max(max, {
-        key: "form.error.rate.rate_percent",
-        context: { min, max }
-      });
-    },
-    array: (field) => {
-      if (typeof field.extra.of === "object") {
-        if (field.required) {
-          field.extra.min = 1;
-        }
-        let arrayValidator = yup.array().nullable().of(yupTypeMap[field.extra.of.type](field.extra.of));
-        if (field.extra.length)
-          arrayValidator = arrayValidator.length(field.extra.length, {
-            key: "form.error.array.length",
-            context: {
-              length: field.extra.length
+import { array, boolean as external_yup_boolean, mixed, number, string } from "yup";
+import { AFM_VALIDATOR, AMKA_VALIDATOR, DATETIME_VALIDATOR, DATE_VALIDATOR, EARLIER_THAN_DATETIME_VALIDATOR, EARLIER_THAN_VALIDATOR, FILE_MAX_SIZE_VALIDATOR, IBAN_VALIDATOR, IMAGE_DIMENSION_VALIDATOR, LATER_THAN_DATETIME_VALIDATOR, LATER_THAN_VALIDATOR, MOBILE_PHONE_VALIDATOR, OTP_VALIDATOR, PHONE_NUMBER_VALIDATOR, POSTALCODE_VALIDATOR, TEXT_LIMIT_VALIDATOR, UUID4_VALIDATOR, getYupObjectShape } from "./utils/index.js";
+import { EMAIL_VALIDATOR } from "./utils/email.js";
+import { INT_VALIDATOR } from "./utils/int.js";
+import { NUMBER_VALIDATOR } from "./utils/number.js";
+const getYUPTypeMap = (validatorRegistry)=>{
+    const yupTypeMap = {
+        file: (field)=>mixed().transform((value)=>{
+                if (!value || 0 === value.length) return null;
+                return value;
+            }).nullable().test(FILE_MAX_SIZE_VALIDATOR(field)),
+        string: (field)=>{
+            if (field.trim) return string().trim();
+            return string();
+        },
+        boolean: ()=>external_yup_boolean().nullable().transform((value)=>{
+                if ('' === value || 'string' == typeof value) return null;
+                if ('boolean' == typeof value) return value;
+                if (0 === value || 1 === value) return Boolean(value);
+                return value;
+            }),
+        object: (field)=>getYupObjectShape(field.extra.fields, yupTypeMap),
+        rate: (field)=>{
+            const min = field?.min ? field.min : 0;
+            const max = field?.max ? field.max : 100;
+            return number().transform((v, o)=>'' === o ? null : v).nullable().notRequired().integer({
+                key: 'form.error.positive_integer_number'
+            }).min(min, {
+                key: 'form.error.rate.rate_percent',
+                context: {
+                    min: min,
+                    max: max
+                }
+            }).max(max, {
+                key: 'form.error.rate.rate_percent',
+                context: {
+                    min: min,
+                    max: max
+                }
+            });
+        },
+        array: (field)=>{
+            if ('object' == typeof field.extra.of) {
+                if (field.required) field.extra.min = 1;
+                let arrayValidator = array().nullable().of(yupTypeMap[field.extra.of.type](field.extra.of));
+                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,
+                        max: field.extra.max || void 0
+                    }
+                });
+                if (field.extra.max) arrayValidator = arrayValidator.max(field.extra.max, {
+                    key: 'form.error.array.max',
+                    context: {
+                        min: field.extra.min || void 0,
+                        max: field.extra.max
+                    }
+                });
+                return arrayValidator;
             }
-          });
-        if (field.extra.min)
-          arrayValidator = arrayValidator.min(field.extra.min, {
-            key: "form.error.array.min",
-            context: {
-              min: field.extra.min,
-              max: field.extra.max || void 0
-            }
-          });
-        if (field.extra.max)
-          arrayValidator = arrayValidator.max(field.extra.max, {
-            key: "form.error.array.max",
-            context: {
-              min: field.extra.min || void 0,
-              max: field.extra.max
-            }
-          });
-        return arrayValidator;
-      } else if (typeof field.extra.of === "string") {
-        return yup.array().of(yupTypeMap[field.extra.of]());
-      } else {
-        return yup.array().of(yup.string());
-      }
-    },
-    number: () => yup.mixed().transform((_, val) => val !== "" ? Number(val) : void 0).test(NUMBER_VALIDATOR()),
-    int: () => yup.mixed().transform((_, val) => val !== "" ? Number(val) : void 0).test(NUMBER_VALIDATOR()).test(INT_VALIDATOR()),
-    email: (field) => field.trim ? yup.string().trim().test(EMAIL_VALIDATOR) : yup.string().test(EMAIL_VALIDATOR),
-    afm: (field) => field.trim ? yup.string().trim().test(AFM_VALIDATOR) : yup.string().test(AFM_VALIDATOR),
-    amka: (field) => field.trim ? yup.string().trim().test(AMKA_VALIDATOR) : yup.string().test(AMKA_VALIDATOR),
-    uuid4: (field) => field.trim ? yup.string().trim().test(UUID4_VALIDATOR) : yup.string().test(UUID4_VALIDATOR),
-    iban: (field) => field.trim ? yup.string().trim().test(IBAN_VALIDATOR(field)) : yup.string().trim().test(IBAN_VALIDATOR(field)),
-    otp: (field) => yup.string().trim().test(OTP_VALIDATOR(field)),
-    text: (field) => {
-      if (field?.extra?.limit?.max || !!field?.extra?.limit?.min) {
-        return field.trim ? yup.string().trim().test(TEXT_LIMIT_VALIDATOR(field)) : yup.string().test(TEXT_LIMIT_VALIDATOR(field));
-      } else {
-        return field.trim ? yup.string().trim() : yup.string();
-      }
-    },
-    image: (field) => {
-      return yup.mixed().transform((value) => {
-        if (!value.length || value.length === 0) {
-          return null;
-        }
-        return value;
-      }).nullable().test(FILE_MAX_SIZE_VALIDATOR(field)).test(IMAGE_DIMENSION_VALIDATOR(field));
-    },
-    postal_code: (field) => field.trim ? yup.string().trim().test(POSTALCODE_VALIDATOR(field)) : yup.string().test(POSTALCODE_VALIDATOR(field)),
-    mobile_phone: (field) => field.trim ? yup.string().trim().test(MOBILE_PHONE_VALIDATOR) : yup.string().test(MOBILE_PHONE_VALIDATOR),
-    phone_number: (field) => field.trim ? yup.string().trim().test(PHONE_NUMBER_VALIDATOR(field)) : yup.string().test(PHONE_NUMBER_VALIDATOR(field)),
-    "choice:multiple": () => yup.array().of(yup.string()).nullable(),
-    "choice:single": () => yup.string().nullable(),
-    date: (field) => {
-      let schema = yup.string().nullable();
-      if (field?.extra?.min) {
-        schema = schema.test(LATER_THAN_VALIDATOR(field));
-      }
-      if (field?.extra?.max) {
-        schema = schema.test(EARLIER_THAN_VALIDATOR(field));
-      } else {
-        schema = schema.test(DATE_VALIDATOR);
-      }
-      return schema;
-    },
-    datetime: (field) => {
-      if (field?.extra?.min) {
-        return yup.string().test(LATER_THAN_DATETIME_VALIDATOR(field));
-      }
-      if (field?.extra?.max) {
-        return yup.string().test(EARLIER_THAN_DATETIME_VALIDATOR(field));
-      }
-      return yup.string().test(DATETIME_VALIDATOR);
-    },
-    ...validatorRegistry
-  };
-  return yupTypeMap;
+            if ('string' == typeof field.extra.of) return array().of(yupTypeMap[field.extra.of]());
+            return array().of(string());
+        },
+        number: ()=>mixed().transform((_, val)=>'' !== val ? Number(val) : void 0).test(NUMBER_VALIDATOR()),
+        int: ()=>mixed().transform((_, val)=>'' !== val ? Number(val) : void 0).test(NUMBER_VALIDATOR()).test(INT_VALIDATOR()),
+        email: (field)=>field.trim ? string().trim().test(EMAIL_VALIDATOR) : string().test(EMAIL_VALIDATOR),
+        afm: (field)=>field.trim ? string().trim().test(AFM_VALIDATOR) : string().test(AFM_VALIDATOR),
+        amka: (field)=>field.trim ? string().trim().test(AMKA_VALIDATOR) : string().test(AMKA_VALIDATOR),
+        uuid4: (field)=>field.trim ? string().trim().test(UUID4_VALIDATOR) : string().test(UUID4_VALIDATOR),
+        iban: (field)=>field.trim ? string().trim().test(IBAN_VALIDATOR(field)) : string().trim().test(IBAN_VALIDATOR(field)),
+        otp: (field)=>string().trim().test(OTP_VALIDATOR(field)),
+        text: (field)=>{
+            if (field?.extra?.limit?.max || !!field?.extra?.limit?.min) return field.trim ? string().trim().test(TEXT_LIMIT_VALIDATOR(field)) : string().test(TEXT_LIMIT_VALIDATOR(field));
+            return field.trim ? string().trim() : string();
+        },
+        image: (field)=>mixed().transform((value)=>{
+                if (!value.length || 0 === value.length) return null;
+                return value;
+            }).nullable().test(FILE_MAX_SIZE_VALIDATOR(field)).test(IMAGE_DIMENSION_VALIDATOR(field)),
+        postal_code: (field)=>field.trim ? string().trim().test(POSTALCODE_VALIDATOR(field)) : string().test(POSTALCODE_VALIDATOR(field)),
+        mobile_phone: (field)=>field.trim ? string().trim().test(MOBILE_PHONE_VALIDATOR) : string().test(MOBILE_PHONE_VALIDATOR),
+        phone_number: (field)=>field.trim ? string().trim().test(PHONE_NUMBER_VALIDATOR(field)) : string().test(PHONE_NUMBER_VALIDATOR(field)),
+        'choice:multiple': ()=>array().of(string()).nullable(),
+        'choice:single': ()=>string().nullable(),
+        date: (field)=>{
+            let schema = string().nullable();
+            if (field?.extra?.min) schema = schema.test(LATER_THAN_VALIDATOR(field));
+            schema = field?.extra?.max ? schema.test(EARLIER_THAN_VALIDATOR(field)) : schema.test(DATE_VALIDATOR);
+            return schema;
+        },
+        datetime: (field)=>{
+            if (field?.extra?.min) return string().test(LATER_THAN_DATETIME_VALIDATOR(field));
+            if (field?.extra?.max) return string().test(EARLIER_THAN_DATETIME_VALIDATOR(field));
+            return string().test(DATETIME_VALIDATOR);
+        },
+        ...validatorRegistry
+    };
+    return yupTypeMap;
 };
 function useValidationSchema(fields, validatorRegistry) {
-  return useMemo(() => {
-    const yupTypeMap = getYUPTypeMap(validatorRegistry);
-    return getYupObjectShape(fields, yupTypeMap, validatorRegistry);
-  }, [fields, validatorRegistry]);
+    return useMemo(()=>{
+        const yupTypeMap = getYUPTypeMap(validatorRegistry);
+        return getYupObjectShape(fields, yupTypeMap, validatorRegistry);
+    }, [
+        fields,
+        validatorRegistry
+    ]);
 }
-export {
-  getYUPTypeMap,
-  useValidationSchema
-};
-//# sourceMappingURL=index.js.map
+export { getYUPTypeMap, useValidationSchema };

package/validators/utils/afm.js

@@ -0,0 +1,19 @@
+function validateAFM(afm) {
+    if (9 !== afm.length) return false;
+    if (!/^\d+$/.test(afm)) return false;
+    if (afm === '0'.repeat(9)) 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;
+}
+const AFM_VALIDATOR = {
+    name: 'afm-validator',
+    message: 'form.error.afm',
+    test: (value)=>{
+        if (value) return validateAFM(value);
+        return true;
+    }
+};
+export { AFM_VALIDATOR, validateAFM };

package/validators/utils/amka.js

@@ -0,0 +1,27 @@
+function digitSum(number) {
+    const sum = number > 9 ? 1 : 0;
+    return sum + number % 10;
+}
+function validateAMKA(amka) {
+    amka = String(amka);
+    const checkDigitIndex = amka.length - 1;
+    let sum = 0;
+    amka.substring(0, checkDigitIndex).split('').reverse().forEach(function(value, index) {
+        const weight = (index + 1) % 2 + 1;
+        sum += digitSum(parseInt(value, 10) * weight);
+    });
+    const sumMod10 = sum % 10;
+    if (0 === sumMod10) return '0' === amka.substring(checkDigitIndex);
+    return amka.substring(checkDigitIndex) === 10 - sumMod10 + '';
+}
+const AMKA_VALIDATOR = {
+    name: 'amka-validator',
+    message: 'form.error.amka',
+    test: (value)=>{
+        if (!value) return true;
+        const AMKA_REGEX = /^[0-9]{11}$/;
+        if (!AMKA_REGEX.test(value) || '00000000000' === value) return false;
+        return validateAMKA(value);
+    }
+};
+export { AMKA_VALIDATOR, validateAMKA };

package/validators/utils/date.d.ts

@@ -1,5 +1,5 @@
-import type { FieldSpec } from '@digigov/form/types';
-import type { ValidatorSchema } from '@digigov/form/validators/types';
+import type { FieldSpec } from '../../types.js';
+import type { ValidatorSchema } from '../types.js';
 export declare const LATER_THAN_VALIDATOR: (field: FieldSpec) => ValidatorSchema;
 export declare const EARLIER_THAN_VALIDATOR: (field: FieldSpec) => ValidatorSchema;
 export declare const DATE_VALIDATOR: {

package/validators/utils/date.js

@@ -0,0 +1,95 @@
+import dayjs from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat.js";
+dayjs.extend(customParseFormat);
+const VALID_DATE_FORMATS = [
+    'DD/MM/YYYY'
+];
+const DATE_CACHE = {};
+const onlyNumbersRegex = /^\d+$/;
+const getDate = (v)=>DATE_CACHE[v] ? DATE_CACHE[v] : dayjs(v, VALID_DATE_FORMATS, true);
+const getDaysInMonth = (month, year)=>dayjs(`${year}-${month}-01`).daysInMonth();
+const checkPartialDate = (value)=>{
+    const [day, month, year] = value.split('/');
+    if (day && !month && !year) return 'form.error.date.invalid_month_year';
+    if (!day && month && !year) return 'form.error.date.invalid_day_year';
+    if (!day && !month && year) return 'form.error.date.invalid_day_month';
+    if (day && month && !year) return 'form.error.date.invalid_year';
+    if (day && !month && year) return 'form.error.date.invalid_month';
+    if (!day && month && year) return 'form.error.date.invalid_day';
+    if (day && month) {
+        const dayNum = parseInt(day);
+        const monthNum = parseInt(month);
+        const validYear = onlyNumbersRegex.test(year) ? year : void 0;
+        if (!validYear || year.length < 4) return 'form.error.date.invalid';
+        const yearNum = parseInt(validYear);
+        const maxDay = getDaysInMonth(monthNum, yearNum);
+        if (dayNum < 1 || dayNum > maxDay) return {
+            key: 'form.error.date.invalid_day_range',
+            context: {
+                maxDay: maxDay
+            }
+        };
+        if (monthNum < 1 || monthNum > 12) return 'form.error.datetime.invalid_month_range';
+    }
+    return 'form.error.date.invalid';
+};
+const LATER_THAN_VALIDATOR = (field)=>{
+    let minDate;
+    const params = field.extra || {};
+    if ('now' === params.min) {
+        const today = new Date();
+        minDate = new Date(today);
+    } else minDate = getDate(params.min).toDate();
+    const minPreviousDate = new Date(minDate);
+    minPreviousDate.setDate(minDate.getDate() - 1);
+    return {
+        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;
+        }
+    };
+};
+const EARLIER_THAN_VALIDATOR = (field)=>{
+    let maxDate;
+    const params = field.extra || {};
+    if ('now' === params.max) {
+        const today = new Date();
+        maxDate = new Date(today);
+    } else maxDate = getDate(params.max).toDate();
+    const maxNextDate = new Date(maxDate);
+    maxNextDate.setDate(maxDate.getDate() + 1);
+    return {
+        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;
+        }
+    };
+};
+const DATE_VALIDATOR = {
+    name: 'date-validator',
+    message: (v)=>checkPartialDate(v.value),
+    test: function(value) {
+        if (!value) return true;
+        const date = getDate(value);
+        return date.isValid();
+    }
+};
+export { DATE_VALIDATOR, EARLIER_THAN_VALIDATOR, LATER_THAN_VALIDATOR };

package/validators/utils/datetime.d.ts

@@ -1,5 +1,5 @@
-import type { FieldSpec } from '@digigov/form/types';
-import type { ValidatorSchema } from '@digigov/form/validators/types';
+import type { FieldSpec } from '../../types.js';
+import type { ValidatorSchema } from '../types.js';
 export declare const LATER_THAN_DATETIME_VALIDATOR: (field: FieldSpec) => ValidatorSchema;
 export declare const EARLIER_THAN_DATETIME_VALIDATOR: (field: FieldSpec) => ValidatorSchema;
 export declare const DATETIME_VALIDATOR: {