@digigov/form 2.0.0-8de46296 → 2.0.0-96651090

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

@@ -0,0 +1,9 @@
+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 | 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;

package/validators/utils/iban.js

@@ -0,0 +1,104 @@
+function validateIban(value, countryCode) {
+    value = value.replace(/\s/g, '').replace(/-/g, '');
+    if (value.match(/^[0-9]*$/i)) {
+        if (25 !== value.length) return false;
+    } else {
+        value = value.toUpperCase();
+        if (countryCode) {
+            if (!value.startsWith(countryCode.toUpperCase())) return false;
+            if (value.length === ibanCountryCodesLengths[countryCode.toUpperCase()]) return true;
+        }
+        if (27 !== value.length) return false;
+    }
+    return true;
+}
+const IBAN_VALIDATOR = (field)=>{
+    const countryCode = field?.extra?.country;
+    return {
+        name: 'iban-validator',
+        message: 'form.error.iban',
+        test: (value)=>{
+            if (!value) return true;
+            return validateIban(value, countryCode);
+        }
+    };
+};
+const ibanCountryCodesLengths = {
+    AD: 24,
+    AT: 20,
+    AZ: 28,
+    BH: 22,
+    BY: 28,
+    BE: 16,
+    BA: 20,
+    BR: 29,
+    BG: 22,
+    CR: 22,
+    HR: 21,
+    CY: 28,
+    CZ: 24,
+    DK: 18,
+    DO: 28,
+    EG: 29,
+    SV: 28,
+    EE: 20,
+    FO: 18,
+    FI: 18,
+    FR: 27,
+    GE: 22,
+    DE: 22,
+    GI: 23,
+    GR: 27,
+    GL: 18,
+    GT: 28,
+    VA: 22,
+    HU: 28,
+    IS: 26,
+    IQ: 23,
+    IE: 22,
+    IL: 23,
+    IT: 27,
+    JO: 30,
+    KZ: 20,
+    XK: 20,
+    KW: 30,
+    LV: 21,
+    LB: 28,
+    LI: 21,
+    LT: 20,
+    LU: 20,
+    MT: 31,
+    MR: 27,
+    MU: 30,
+    MD: 24,
+    MC: 27,
+    ME: 22,
+    NL: 18,
+    MK: 19,
+    NO: 15,
+    PK: 24,
+    PS: 29,
+    PL: 28,
+    PT: 25,
+    QA: 29,
+    RO: 24,
+    LC: 32,
+    SM: 27,
+    ST: 25,
+    SA: 24,
+    RS: 22,
+    SC: 31,
+    SK: 24,
+    SI: 19,
+    ES: 24,
+    SE: 24,
+    CH: 21,
+    TL: 23,
+    TN: 24,
+    TR: 26,
+    UA: 29,
+    AE: 23,
+    GB: 22,
+    VG: 24
+};
+export { IBAN_VALIDATOR, validateIban };

package/validators/utils/image.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 IMAGE_DIMENSION_VALIDATOR: (field: FieldSpec) => ValidatorSchema;

package/validators/utils/image.js

@@ -0,0 +1,65 @@
+const DEFAULT_IMAGE_MAX_HEIGHT_SIZE = 2000;
+const DEFAULT_IMAGE_MAX_WIDTH_SIZE = 2000;
+const DEFAULT_IMAGE_MIN_HEIGHT_SIZE = 100;
+const DEFAULT_IMAGE_MIN_WIDTH_SIZE = 100;
+function getImageDimensions(file) {
+    return new Promise((resolve, reject)=>{
+        const reader = new FileReader();
+        reader.onload = (event)=>{
+            const img = new Image();
+            img.onload = ()=>{
+                resolve({
+                    width: img.width,
+                    height: img.height
+                });
+            };
+            img.onerror = reject;
+            const result = event?.target?.result;
+            if (result && 'string' == typeof result) img.src = result;
+            else reject(new Error('Invalid file format'));
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
+}
+const IMAGE_DIMENSION_VALIDATOR = (field)=>({
+        name: 'image-dimension-validator',
+        message: (value)=>{
+            const minHeight = field?.extra?.limit?.minHeight || DEFAULT_IMAGE_MIN_HEIGHT_SIZE;
+            const minWidth = field?.extra?.limit?.minWidth || DEFAULT_IMAGE_MIN_WIDTH_SIZE;
+            const maxHeight = field?.extra?.limit?.maxHeight || DEFAULT_IMAGE_MAX_HEIGHT_SIZE;
+            const maxWidth = field?.extra?.limit?.maxWidth || DEFAULT_IMAGE_MAX_WIDTH_SIZE;
+            if (!value || 0 === value.length) return {
+                name: 'image-validator',
+                message: 'form.error.required'
+            };
+            return {
+                key: 'form.error.image.image_dimension_size',
+                context: {
+                    maxHeight: maxHeight,
+                    maxWidth: maxWidth,
+                    minHeight: minHeight,
+                    minWidth: minWidth
+                }
+            };
+        },
+        test: async (value)=>{
+            if (!value || 0 === value.length) return true;
+            const file = value[0];
+            const { width, height } = await getImageDimensions(file);
+            const maxHeight = field?.extra?.limit?.maxHeight || DEFAULT_IMAGE_MAX_HEIGHT_SIZE;
+            const maxWidth = field?.extra?.limit?.maxWidth || DEFAULT_IMAGE_MAX_WIDTH_SIZE;
+            const minHeight = field?.extra?.limit?.minHeight || DEFAULT_IMAGE_MIN_HEIGHT_SIZE;
+            const minWidth = field?.extra?.limit?.minWidth || DEFAULT_IMAGE_MIN_WIDTH_SIZE;
+            if (!file) return true;
+            try {
+                if (height > maxHeight || width > maxWidth) return false;
+                if (height < minHeight || width < minWidth) return false;
+                return true;
+            } catch (error) {
+                console.error('Error getting image dimensions:', error);
+                return false;
+            }
+        }
+    });
+export { IMAGE_DIMENSION_VALIDATOR };

package/validators/utils/index.d.ts

@@ -1,15 +1,18 @@
 import * as yup from 'yup';
-import { FieldSpec } from '@digigov/form/types';
-import { ValidatorSchema } from '@digigov/form/validators/types';
-export * from '@digigov/form/validators/utils/afm';
-export * from '@digigov/form/validators/utils/file';
-export * from '@digigov/form/validators/utils/iban';
-export * from '@digigov/form/validators/utils/otp';
-export * from '@digigov/form/validators/utils/image';
-export * from '@digigov/form/validators/utils/phone';
-export * from '@digigov/form/validators/utils/postal_code';
-export * from '@digigov/form/validators/utils/uuid4';
-export * from '@digigov/form/validators/utils/text_limit';
+import type { FieldSpec } from '../../types.js';
+import type { ValidatorSchema } from '../types.js';
+export * from './afm.js';
+export * from './amka.js';
+export * from './file.js';
+export * from './iban.js';
+export * from './otp.js';
+export * from './image.js';
+export * from './phone.js';
+export * from './postal_code.js';
+export * from './uuid4.js';
+export * from './text_limit.js';
+export * from './date.js';
+export * from './datetime.js';
 export declare function getYupField(field: FieldSpec, yupTypeMap: Record<string, any>): any;
 export declare function computeShape(fields: FieldSpec[], yupTypeMap: Record<string, ValidatorSchema>, validatorRegistry: Record<string, ValidatorSchema[]> | undefined): {};
 export declare function getYupObjectShape(fields: FieldSpec[] | any, yupTypeMap: Record<string, any>, validatorRegistry?: Record<string, ValidatorSchema[]>): yup.ObjectSchema<{

package/validators/utils/index.js

@@ -1,89 +1,66 @@
-import * as yup from 'yup';
-export * from '@digigov/form/validators/utils/afm';
-export * from '@digigov/form/validators/utils/file';
-export * from '@digigov/form/validators/utils/iban';
-export * from '@digigov/form/validators/utils/otp';
-export * from '@digigov/form/validators/utils/image';
-export * from '@digigov/form/validators/utils/phone';
-export * from '@digigov/form/validators/utils/postal_code';
-export * from '@digigov/form/validators/utils/uuid4';
-export * from '@digigov/form/validators/utils/text_limit';
-export function getYupField(field, yupTypeMap) {
-  var yupField = yupTypeMap[(field === null || field === void 0 ? void 0 : field.type) || 'string'] || yupTypeMap['string'];
-  return yupField(field);
+import { lazy, object } from "yup";
+export * from "./afm.js";
+export * from "./amka.js";
+export * from "./file.js";
+export * from "./iban.js";
+export * from "./otp.js";
+export * from "./image.js";
+export * from "./phone.js";
+export * from "./postal_code.js";
+export * from "./uuid4.js";
+export * from "./text_limit.js";
+export * from "./date.js";
+export * from "./datetime.js";
+function getYupField(field, yupTypeMap) {
+    const yupField = yupTypeMap[field?.type || 'string'] || yupTypeMap['string'];
+    return yupField(field);
 }
-export function computeShape(fields, yupTypeMap, validatorRegistry) {
-  var fieldSchemas = {};
-  var objectFields = {};
-  fields.forEach(function (field) {
-    var yupField = getYupField(field, yupTypeMap);
-    if (field.condition) {
-      var _loop = function _loop(key) {
-        var then, otherwise;
-        if (field.condition[key].then) {
-          var _field$condition$key$, _field$condition$key$2;
-          if (((_field$condition$key$ = field.condition[key].then) === null || _field$condition$key$ === void 0 ? void 0 : _field$condition$key$.required) === false) {
-            then = yupField.nullable();
-          } else if (((_field$condition$key$2 = field.condition[key].then) === null || _field$condition$key$2 === void 0 ? void 0 : _field$condition$key$2.required) === true) {
-            then = yupField.nullable().required('form.error.required');
-          }
+function computeShape(fields, yupTypeMap, validatorRegistry) {
+    const fieldSchemas = {};
+    const objectFields = {};
+    fields.forEach((field)=>{
+        let yupField = getYupField(field, yupTypeMap);
+        if (field.condition) for(const key in field.condition){
+            let then, otherwise;
+            if (field.condition[key].then) {
+                if (field.condition[key].then?.required === false) then = yupField.nullable();
+                else if (field.condition[key].then?.required === true) then = yupField.nullable().required('form.error.required');
+            }
+            if (field.condition[key].else) {
+                if (field.condition[key].else?.required === false) otherwise = yupField.nullable();
+                else if (field.condition[key].else?.required === true) otherwise = yupField.nullable().required('form.error.required');
+            }
+            if (then || otherwise) yupField = yupField.when(key, {
+                is: (val)=>{
+                    const is = field.condition[key].is;
+                    if (is === val || Array.isArray(val) && val.includes(is)) return true;
+                    return false;
+                },
+                then,
+                otherwise
+            });
         }
-        if (field.condition[key]["else"]) {
-          var _field$condition$key$3, _field$condition$key$4;
-          if (((_field$condition$key$3 = field.condition[key]["else"]) === null || _field$condition$key$3 === void 0 ? void 0 : _field$condition$key$3.required) === false) {
-            otherwise = yupField.nullable();
-          } else if (((_field$condition$key$4 = field.condition[key]["else"]) === null || _field$condition$key$4 === void 0 ? void 0 : _field$condition$key$4.required) === true) {
-            otherwise = yupField.nullable().required('form.error.required');
-          }
-        }
-        if (then || otherwise) {
-          yupField = yupField.when(key, {
-            is: function is(val) {
-              //@ts-ignore
-              var is = field.condition[key].is;
-              if (is === val || Array.isArray(val) && val.includes(is)) {
-                return true;
-              } else {
-                return false;
-              }
-            },
-            then: then,
-            otherwise: otherwise
-          });
-        }
-      };
-      for (var key in field.condition) {
-        _loop(key);
-      }
-    } else if (field.required) {
-      yupField = yupField.nullable().required('form.error.required');
-    }
-    if (validatorRegistry && field.type && validatorRegistry[field.type]) {
-      validatorRegistry[field.type].forEach(function (validator) {
-        yupField = yupField.test(validator);
-      });
-    }
-    if (field.validators) {
-      field.validators.forEach(function (validator) {
-        yupField = yupField.test(validator);
-      });
+        else if (field.required) yupField = yupField.nullable().required('form.error.required');
+        if (validatorRegistry && field.type && validatorRegistry[field.type]) if (Array.isArray(validatorRegistry[field.type])) validatorRegistry[field.type].forEach((validator)=>{
+            yupField = yupField.test(validator);
+        });
+        else yupField = yupField.test(validatorRegistry[field.type]);
+        if (field.validators) field.validators.forEach((validator)=>{
+            yupField = yupField.test(validator);
+        });
+        fieldSchemas[field.key] = yupField;
+    });
+    for(const objectKey in objectFields)fieldSchemas[objectKey] = getYupObjectShape(objectFields[objectKey], yupTypeMap, validatorRegistry);
+    return fieldSchemas;
+}
+function getYupObjectShape(fields, yupTypeMap, validatorRegistry) {
+    if (!fields.current) {
+        const fieldSchemas = computeShape(fields, yupTypeMap, validatorRegistry);
+        return object().shape(fieldSchemas);
     }
-    fieldSchemas[field.key] = yupField;
-  });
-  for (var objectKey in objectFields) {
-    fieldSchemas[objectKey] = getYupObjectShape(objectFields[objectKey], yupTypeMap, validatorRegistry);
-  }
-  return fieldSchemas;
+    return lazy(function() {
+        const fieldSchemas = computeShape(Object.values(fields.current).filter((f)=>!f.key.includes('.')), yupTypeMap, validatorRegistry);
+        return object().shape(fieldSchemas);
+    });
 }
-export function getYupObjectShape(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-fields, yupTypeMap, validatorRegistry) {
-  if (!fields.current) {
-    var fieldSchemas = computeShape(fields, yupTypeMap, validatorRegistry);
-    return yup.object().shape(fieldSchemas);
-  }
-  return yup.lazy(function () {
-    var fieldSchemas = computeShape(Object.values(fields.current), yupTypeMap, validatorRegistry);
-    return yup.object().shape(fieldSchemas);
-  });
-}
+export { computeShape, getYupField, getYupObjectShape };

package/validators/utils/int.d.ts

@@ -1,3 +1,3 @@
-import { ValidatorSchema } from '@digigov/form/validators/types';
+import type { ValidatorSchema } from '../types.js';
 export declare function validateIntNumber(number: number): boolean;
 export declare const INT_VALIDATOR: () => ValidatorSchema;