@digigov/form 2.0.0-a402a664 → 2.0.0-a64dc016

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,18 +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/amka';
-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 * from '@digigov/form/validators/utils/date';
-export * from '@digigov/form/validators/utils/datetime';
+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,100 +1,66 @@
-import * as yup from "yup";
-export * from "@digigov/form/validators/utils/afm";
-export * from "@digigov/form/validators/utils/amka";
-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 * from "@digigov/form/validators/utils/date";
-export * from "@digigov/form/validators/utils/datetime";
+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);
+    const yupField = yupTypeMap[field?.type || 'string'] || yupTypeMap['string'];
+    return yupField(field);
 }
 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");
-          }
+    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) {
-          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;
-              } else {
-                return false;
-              }
-            },
-            then,
-            otherwise
-          });
-        }
-      }
-    } else if (field.required) {
-      yupField = yupField.nullable().required("form.error.required");
-    }
-    if (validatorRegistry && field.type && validatorRegistry[field.type]) {
-      validatorRegistry[field.type].forEach((validator) => {
-        yupField = yupField.test(validator);
-      });
-    }
-    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;
+        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 yup.object().shape(fieldSchemas);
-  }
-  return yup.lazy(function() {
-    const fieldSchemas = computeShape(
-      Object.values(fields.current).filter(
-        (f) => !f.key.includes(".")
-      ),
-      yupTypeMap,
-      validatorRegistry
-    );
-    return yup.object().shape(fieldSchemas);
-  });
+    if (!fields.current) {
+        const fieldSchemas = computeShape(fields, yupTypeMap, validatorRegistry);
+        return object().shape(fieldSchemas);
+    }
+    return lazy(function() {
+        const fieldSchemas = computeShape(Object.values(fields.current).filter((f)=>!f.key.includes('.')), yupTypeMap, validatorRegistry);
+        return object().shape(fieldSchemas);
+    });
 }
-export {
-  computeShape,
-  getYupField,
-  getYupObjectShape
-};
-//# sourceMappingURL=index.js.map
+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;

package/validators/utils/int.js

@@ -0,0 +1,13 @@
+function validateIntNumber(number) {
+    if (void 0 === number) return false;
+    return Number.isInteger(number) && Number(number) > 0;
+}
+const INT_VALIDATOR = ()=>({
+        name: 'int-validator',
+        message: 'form.error.positive_integer_number',
+        test: (value)=>{
+            if (void 0 === value) return true;
+            return validateIntNumber(value);
+        }
+    });
+export { INT_VALIDATOR, validateIntNumber };

package/validators/utils/number.d.ts

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

package/validators/utils/number.js

@@ -0,0 +1,12 @@
+function validateNumber(number) {
+    return !Number.isNaN(number);
+}
+const NUMBER_VALIDATOR = ()=>({
+        name: 'number-validator',
+        message: 'form.error.number',
+        test: (value)=>{
+            if (void 0 === value) return true;
+            return validateNumber(value);
+        }
+    });
+export { NUMBER_VALIDATOR, validateNumber };

package/validators/utils/otp.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 validateOtp(value: string, maxLength: number): boolean;
 export declare const OTP_VALIDATOR: (field: FieldSpec) => ValidatorSchema;

package/validators/utils/otp.js

@@ -0,0 +1,21 @@
+function validateOtp(value, maxLength) {
+    if (value.length === maxLength) return true;
+    return false;
+}
+const OTP_VALIDATOR = (field)=>{
+    const maxLength = field?.maxLength;
+    return {
+        name: 'otp-validator',
+        message: {
+            key: 'form.error.otp.less_than',
+            context: {
+                maxLength: field?.maxLength
+            }
+        },
+        test: (value)=>{
+            if (!value) return true;
+            return validateOtp(value, maxLength);
+        }
+    };
+};
+export { OTP_VALIDATOR, validateOtp };

package/validators/utils/phone.d.ts

@@ -1,5 +1,5 @@
-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 type PhoneNumberType = 'landline' | 'mobile' | null;
 export declare function discoverPhoneType(phoneNumber: string, config: any): string;
 export declare function validatePhoneNumber(phoneNumber: string, countries?: string[], typeOfPhoneNumber?: PhoneNumberType): boolean;