@digigov/form 2.0.0-13876dba → 2.0.0-16fbe090

package/validators/index.js

@@ -1,144 +1,117 @@
 import { useMemo } from "react";
-import * as yup from "yup";
-import {
-  getYupObjectShape,
-  AFM_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 { INT_VALIDATOR } from "@digigov/form/validators/utils/int";
-import { NUMBER_VALIDATOR } from "@digigov/form/validators/utils/number";
-const getYUPTypeMap = () => {
-  const yupTypeMap = {
-    file: (field) => {
-      return yup.mixed().transform((value) => {
-        if (!value.length) {
-          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);
-    },
-    array: (field) => {
-      if (typeof field.extra.of === "object") {
-        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
+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
-            }
-          });
-        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 {
-        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().email("form.error.email") : yup.string().email("form.error.email"),
-    afm: (field) => field.trim ? yup.string().trim().test(AFM_VALIDATOR) : yup.string().test(AFM_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);
-    }
-  };
-  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();
-    return getYupObjectShape(fields, yupTypeMap, 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/types.d.ts

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

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.d.ts

@@ -0,0 +1,6 @@
+export declare function validateAMKA(amka: string): boolean;
+export declare const AMKA_VALIDATOR: {
+    name: string;
+    message: string;
+    test: (value: any) => boolean;
+};

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,9 +1,9 @@
-import { FieldSpec } from '@digigov/form/types';
-import { 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: {
     name: string;
-    message: (v: any) => string;
+    message: (v: any) => string | object;
     test: (value: string) => any;
 };

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,9 +1,9 @@
-import { FieldSpec } from '@digigov/form/types';
-import { 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: {
     name: string;
-    message: (v: any) => string;
+    message: (v: any) => string | object;
     test: (value: string) => any;
 };

package/validators/utils/datetime.js

@@ -0,0 +1,121 @@
+import dayjs from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat.js";
+dayjs.extend(customParseFormat);
+const VALID_DATETIME_FORMATS = [
+    'DD/MM/YYYY HH:mm'
+];
+const DATETIME_CACHE = {};
+const onlyNumbersRegex = /^\d+$/;
+const getDateTime = (v)=>DATETIME_CACHE[v] ? DATETIME_CACHE[v] : dayjs(v, VALID_DATETIME_FORMATS, true);
+const getDaysInMonth = (month, year)=>dayjs(`${year}-${month}-01`).daysInMonth();
+const checkPartialDateTime = (value)=>{
+    const [datePart, timePart] = value.split(' ');
+    const [day, month, year] = datePart?.split('/') ?? [];
+    const [hours, minutes] = timePart?.split(':') ?? [];
+    const hasDay = Boolean(day);
+    const hasMonth = Boolean(month);
+    const hasYear = Boolean(year);
+    const hasHours = Boolean(hours);
+    const hasMinutes = Boolean(minutes);
+    if (hasDay && !hasMonth && !hasYear && !hasHours && !hasMinutes) return 'form.error.datetime.invalid_month_year_hours_minutes';
+    if (!hasDay && hasMonth && !hasYear && !hasHours && !hasMinutes) return 'form.error.datetime.invalid_day_year_hours_minutes';
+    if (!hasDay && !hasMonth && hasYear && !hasHours && !hasMinutes) return 'form.error.datetime.invalid_day_month_hours_minutes';
+    if (hasDay && hasMonth && !hasYear && !hasHours && !hasMinutes) return 'form.error.datetime.invalid_year_hours_minutes';
+    if (hasDay && !hasMonth && hasYear && !hasHours && !hasMinutes) return 'form.error.datetime.invalid_month_hours_minutes';
+    if (!hasDay && hasMonth && hasYear && !hasHours && !hasMinutes) return 'form.error.datetime.invalid_day_hours_minutes';
+    if (hasDay && hasMonth && hasYear && !hasHours && !hasMinutes) return 'form.error.datetime.invalid__hours_minutes';
+    if (hasDay && hasMonth && hasYear && hasHours && !hasMinutes) return 'form.error.datetime.invalid_minutes';
+    if (hasDay && hasMonth && hasYear && !hasHours && hasMinutes) return 'form.error.datetime.invalid_hours';
+    if (hasDay && !hasMonth && !hasYear && hasHours && !hasMinutes) return 'form.error.datetime.invalid_month_year_minutes';
+    if (hasDay && !hasMonth && !hasYear && !hasHours && hasMinutes) return 'form.error.datetime.invalid_month_year_hours';
+    if (hasDay && !hasMonth && !hasYear && hasHours && hasMinutes) return 'form.error.datetime.invalid_month_year';
+    if (!hasDay && hasMonth && !hasYear && hasHours && !hasMinutes) return 'form.error.datetime.invalid_day_year_minutes';
+    if (!hasDay && hasMonth && !hasYear && !hasHours && hasMinutes) return 'form.error.datetime.invalid_day_year_hours';
+    if (!hasDay && hasMonth && !hasYear && hasHours && hasMinutes) return 'form.error.datetime.invalid_day_year';
+    if (!hasDay && !hasMonth && hasYear && hasHours && !hasMinutes) return 'form.error.datetime.invalid_day_month_minutes';
+    if (!hasDay && !hasMonth && hasYear && !hasHours && hasMinutes) return 'form.error.datetime.invalid_day_month_hours';
+    if (!hasDay && !hasMonth && hasYear && hasHours && hasMinutes) return 'form.error.datetime.invalid_day_month';
+    if (!hasDay && !hasMonth && !hasYear && hasHours && hasMinutes) return 'form.error.datetime.invalid_day_month_year';
+    if (!hasDay && !hasMonth && !hasYear && !hasHours && hasMinutes) return 'form.error.datetime.invalid_day_month_year_hours';
+    if (hasDay && hasMonth && !hasYear && hasHours && !hasMinutes) return 'form.error.datetime.invalid_year_minutes';
+    if (hasDay && hasMonth && !hasYear && !hasHours && hasMinutes) return 'form.error.datetime.invalid_year_hours';
+    if (hasDay && hasMonth && !hasYear && hasHours && hasMinutes) return 'form.error.datetime.invalid_year';
+    if (hasDay && !hasMonth && hasYear && hasHours && !hasMinutes) return 'form.error.datetime.invalid_month_minutes';
+    if (hasDay && !hasMonth && hasYear && !hasHours && hasMinutes) return 'form.error.datetime.invalid_month_hours';
+    if (hasDay && !hasMonth && hasYear && hasHours && hasMinutes) return 'form.error.datetime.invalid_month';
+    if (!hasDay && hasMonth && hasYear && hasHours && !hasMinutes) return 'form.error.datetime.invalid_day_minutes';
+    if (!hasDay && hasMonth && hasYear && !hasHours && hasMinutes) return 'form.error.datetime.invalid_day_hours';
+    if (!hasDay && hasMonth && hasYear && hasHours && hasMinutes) return 'form.error.datetime.invalid_day';
+    if (!hasDay && !hasMonth && !hasYear && hasHours && !hasMinutes) return 'form.error.datetime.invalid_day_month_year_minutes';
+    if (hasDay && hasMonth && hasYear && !hasHours && !hasMinutes) return 'form.error.datetime.invalid_hours_minutes';
+    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.datetime.invalid';
+        const yearNum = parseInt(validYear);
+        const maxDay = getDaysInMonth(monthNum, yearNum);
+        if (dayNum < 1 || dayNum > maxDay) return {
+            key: 'form.error.datetime.invalid_day_range',
+            context: {
+                maxDay: maxDay
+            }
+        };
+        if (monthNum < 1 || monthNum > 12) return 'form.error.datetime.invalid_month_range';
+    }
+    if (hours && minutes) {
+        const hoursNum = parseInt(hours);
+        const minutesNum = parseInt(minutes);
+        if (hoursNum < 0 || hoursNum > 23) return 'form.error.datetime.invalid_hours_range';
+        if (minutesNum < 0 || minutesNum > 59) return 'form.error.datetime.invalid_minutes_range';
+    }
+    return 'form.error.datetime.invalid';
+};
+const LATER_THAN_DATETIME_VALIDATOR = (field)=>{
+    let minDateTime;
+    const params = field.extra || {};
+    minDateTime = 'now' === params.min ? dayjs() : getDateTime(params.min);
+    return {
+        name: 'later-than-datetime',
+        message: {
+            key: 'form.error.datetime.later_than',
+            context: {
+                minDateTime: minDateTime.format('DD/MM/YYYY HH:mm')
+            }
+        },
+        test: function(value) {
+            if (!value) return true;
+            const datetime = getDateTime(value);
+            return datetime.isValid() && datetime.isAfter(minDateTime);
+        }
+    };
+};
+const EARLIER_THAN_DATETIME_VALIDATOR = (field)=>{
+    let maxDateTime;
+    const params = field.extra || {};
+    maxDateTime = 'now' === params.max ? dayjs() : getDateTime(params.max);
+    return {
+        name: 'earlier-than-datetime',
+        message: {
+            key: 'form.error.datetime.earlier_than',
+            context: {
+                maxDateTime: maxDateTime.format('DD/MM/YYYY HH:mm')
+            }
+        },
+        test: function(value) {
+            if (!value) return true;
+            const datetime = getDateTime(value);
+            return datetime.isValid() && datetime.isBefore(maxDateTime);
+        }
+    };
+};
+const DATETIME_VALIDATOR = {
+    name: 'datetime-validator',
+    message: (v)=>checkPartialDateTime(v.value),
+    test: function(value) {
+        if (!value) return true;
+        const datetime = getDateTime(value);
+        return datetime.isValid();
+    }
+};
+export { DATETIME_VALIDATOR, EARLIER_THAN_DATETIME_VALIDATOR, LATER_THAN_DATETIME_VALIDATOR };

package/validators/utils/email.d.ts

@@ -0,0 +1,5 @@
+export declare const EMAIL_VALIDATOR: {
+    name: string;
+    message: string;
+    test: (value: string) => boolean;
+};

package/validators/utils/email.js

@@ -0,0 +1,10 @@
+const EMAIL_VALIDATOR = {
+    name: 'email-validator',
+    message: 'form.error.email',
+    test: (value)=>{
+        if (!value) return true;
+        const EMAIL_REGEX = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+        return EMAIL_REGEX.test(value);
+    }
+};
+export { EMAIL_VALIDATOR };

package/validators/utils/file.d.ts

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

package/validators/utils/file.js

@@ -0,0 +1,31 @@
+const DEFAULT_FILE_MAX_SIZE = 10000000;
+const FILE_MAX_SIZE_VALIDATOR = (field)=>{
+    const maxSizeInBytes = field?.extra?.limit?.maxSize || DEFAULT_FILE_MAX_SIZE;
+    let maxSizeTransformed = maxSizeInBytes / 1048576;
+    let maxSizeText = 'MB';
+    if (0 === Math.round(maxSizeTransformed)) {
+        maxSizeTransformed = Math.round(maxSizeInBytes / 1024);
+        maxSizeText = 'KB';
+    }
+    if (0 === Math.round(maxSizeTransformed)) {
+        maxSizeTransformed = maxSizeInBytes;
+        maxSizeText = 'Bytes';
+    }
+    return {
+        name: 'file-max-size-validator',
+        message: {
+            key: 'file' === field.type ? 'form.error.file_size' : 'form.error.image_size',
+            context: {
+                maxSize: `${maxSizeTransformed} ${maxSizeText}`
+            }
+        },
+        test: (value)=>{
+            if (value) for (const file of Array.from(value)){
+                const maxSize = field?.extra?.limit?.maxSize || DEFAULT_FILE_MAX_SIZE;
+                if (file.size > maxSize) return false;
+            }
+            return true;
+        }
+    };
+};
+export { FILE_MAX_SIZE_VALIDATOR };

package/validators/utils/iban.d.ts

@@ -1,4 +1,4 @@
-import { FieldSpec } from '@digigov/form/types';
-import { ValidatorSchema } from '@digigov/form/validators/types';
+import type { FieldSpec } from '../../types.js';
+import type { ValidatorSchema } from '../types.js';
 export declare function validateIban(value: string, countryCode: string): boolean;
 export declare const IBAN_VALIDATOR: (field: FieldSpec) => ValidatorSchema;