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

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,17 +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';
-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,97 +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 * 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),
-      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;

package/validators/utils/phone.js

@@ -0,0 +1,198 @@
+const countryPhoneData = {
+    GR: [
+        '30',
+        '00',
+        '5005000\\d{3}|8\\d{9,11}|(?:[269]\\d|70)\\d{8}',
+        [
+            10,
+            11,
+            12
+        ],
+        [
+            [
+                '(\\d{2})(\\d{4})(\\d{4})',
+                '$1 $2 $3',
+                [
+                    '21|7'
+                ]
+            ],
+            [
+                '(\\d{4})(\\d{6})',
+                '$1 $2',
+                [
+                    '2(?:2|3[2-57-9]|4[2-469]|5[2-59]|6[2-9]|7[2-69]|8[2-49])|5'
+                ]
+            ],
+            [
+                '(\\d{3})(\\d{3})(\\d{4})',
+                '$1 $2 $3',
+                [
+                    '[2689]'
+                ]
+            ],
+            [
+                '(\\d{3})(\\d{3,4})(\\d{5})',
+                '$1 $2 $3',
+                [
+                    '8'
+                ]
+            ]
+        ],
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        [
+            [
+                '2(?:1\\d\\d|2(?:2[1-46-9]|[36][1-8]|4[1-7]|5[1-4]|7[1-5]|[89][1-9])|3(?:1\\d|2[1-57]|[35][1-3]|4[13]|7[1-7]|8[124-6]|9[1-79])|4(?:1\\d|2[1-8]|3[1-4]|4[13-5]|6[1-578]|9[1-5])|5(?:1\\d|[29][1-4]|3[1-5]|4[124]|5[1-6])|6(?:1\\d|[269][1-6]|3[1245]|4[1-7]|5[13-9]|7[14]|8[1-5])|7(?:1\\d|2[1-5]|3[1-6]|4[1-7]|5[1-57]|6[135]|9[125-7])|8(?:1\\d|2[1-5]|[34][1-4]|9[1-57]))\\d{6}',
+                [
+                    10
+                ]
+            ],
+            [
+                '68[57-9]\\d{7}|(?:69|94)\\d{8}',
+                [
+                    10
+                ]
+            ],
+            [
+                '800\\d{7,9}'
+            ],
+            [
+                '90[19]\\d{7}',
+                [
+                    10
+                ]
+            ],
+            [
+                '70\\d{8}',
+                [
+                    10
+                ]
+            ],
+            0,
+            [
+                '5005000\\d{3}',
+                [
+                    10
+                ]
+            ],
+            0,
+            0,
+            [
+                '8(?:0[16]|12|[27]5|50)\\d{7}',
+                [
+                    10
+                ]
+            ]
+        ]
+    ]
+};
+function expandPhoneNumberStructure(compressed) {
+    const countries = Object.keys(compressed);
+    const expanded = {};
+    for (const country of countries)expanded[country] = {
+        fixedLine: {
+            possibleLengths: {
+                _national: compressed[country][3].map(String)
+            },
+            nationalNumberPattern: compressed[country][11][0][0]
+        },
+        mobile: {
+            nationalNumberPattern: compressed[country][11][1][0]
+        },
+        tollFree: {
+            nationalNumberPattern: compressed[country][11][2][0]
+        },
+        premiumRate: {
+            nationalNumberPattern: compressed[country][11][3][0]
+        },
+        sharedCost: {
+            nationalNumberPattern: compressed[country][11][9][0]
+        },
+        personalNumber: {
+            nationalNumberPattern: compressed[country][11][4][0]
+        },
+        uan: {
+            nationalNumberPattern: compressed[country][11][6][0]
+        },
+        id: country,
+        countryCode: compressed[country][0],
+        internationalPrefix: compressed[country][1]
+    };
+    return expanded;
+}
+const PHONENUMBER_SPEC = expandPhoneNumberStructure(countryPhoneData);
+function discoverPhoneType(phoneNumber, config) {
+    const cleanNumber = phoneNumber.replace(/\D/g, '').replace(/\s/g, '').replace(/^\+/, '').replace(new RegExp('^' + config.internationalPrefix, ''), '').replace(new RegExp('^' + config.countryCode, ''), '');
+    const categories = {
+        landline: config.fixedLine,
+        mobile: config.mobile,
+        'toll-free': config.tollFree,
+        'premium-rate': config.premiumRate
+    };
+    for (const [categoryName, categoryDetails] of Object.entries(categories)){
+        const pattern = new RegExp('^(' + categoryDetails.nationalNumberPattern.replace(/\s/g, '') + ')$', '');
+        if (cleanNumber.match(pattern)) return categoryName;
+    }
+    return 'unknown';
+}
+function getNumberType(phoneNumber, country) {
+    const spec = PHONENUMBER_SPEC[country.toUpperCase()];
+    if (!spec) throw new Error(`Country ${country} is not supported`);
+    const type = discoverPhoneType(phoneNumber, spec);
+    return type;
+}
+function isPhoneNumberValid(phoneNumber, countries, types = [
+    'mobile',
+    'landline'
+]) {
+    return countries.some((country)=>{
+        const numberType = getNumberType(phoneNumber, country);
+        if (numberType && types.includes(numberType)) return true;
+        return false;
+    });
+}
+function isNumberOfType(phoneNumber, country, type) {
+    const numberType = getNumberType(phoneNumber, country);
+    if (numberType === type) return true;
+    return false;
+}
+function validatePhoneNumber(phoneNumber, countries = [
+    'gr'
+], typeOfPhoneNumber) {
+    if (!countries || 0 === countries.length) return true;
+    return isPhoneNumberValid(phoneNumber, countries, typeOfPhoneNumber ? [
+        typeOfPhoneNumber
+    ] : void 0);
+}
+function validateMobile(value) {
+    return isNumberOfType(value, 'gr', 'mobile');
+}
+const MOBILE_PHONE_VALIDATOR = {
+    name: 'mobile-phone-validator',
+    message: 'form.error.mobile_phone',
+    test: (value)=>{
+        if (value) return validateMobile(value);
+        return true;
+    }
+};
+const PHONE_NUMBER_VALIDATOR = (field)=>{
+    const countryCodes = field?.extra?.countries;
+    const typeOfPhone = field?.extra?.phoneType;
+    return {
+        name: 'phone-number-validator',
+        message: ()=>{
+            if ('mobile' === typeOfPhone) return 'form.error.mobile_phone';
+            if ('landline' === typeOfPhone) return 'form.error.landline';
+            return 'form.error.phone_number';
+        },
+        test: (value)=>{
+            if (!value) return true;
+            return validatePhoneNumber(value, countryCodes, typeOfPhone);
+        }
+    };
+};
+export { MOBILE_PHONE_VALIDATOR, PHONE_NUMBER_VALIDATOR, discoverPhoneType, validatePhoneNumber };

package/validators/utils/postal_code.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 validatePostalCode(number: string, countries: string[]): boolean;
 export declare const POSTALCODE_VALIDATOR: (field: FieldSpec) => ValidatorSchema;

package/validators/utils/postal_code.js

@@ -0,0 +1,18 @@
+const CODE_REGEX = /^[12345678][0-9]{4}$/;
+function validatePostalCode(number, countries) {
+    if (!countries) return false;
+    if (1 === countries.length && 'GR' === countries[0].toUpperCase()) return CODE_REGEX.test(number);
+    return true;
+}
+const POSTALCODE_VALIDATOR = (field)=>{
+    const countryCode = field?.extra?.countries;
+    return {
+        name: 'postal-code-validator',
+        message: 'form.error.postalCode',
+        test: (value)=>{
+            if (!value) return true;
+            return validatePostalCode(value, countryCode);
+        }
+    };
+};
+export { POSTALCODE_VALIDATOR, validatePostalCode };