@oneblink/apps-react 2.2.0 → 2.3.0-beta.2

package/dist/services/form-validation.js

@@ -1,562 +1,562 @@
-import validate from 'validate.js';
-import { localisationService } from '@oneblink/apps';
-import { parseDateValue } from './generate-default-data';
-import generateCivicaNameRecordElements from './generateCivicaNameRecordElements';
-import generateFreshdeskDependentFieldElements from './generateFreshdeskDependentFieldElements';
-export const lookupValidationMessage = 'Lookup is required';
-// https://validatejs.org/#validators-datetime
-// Before using it we must add the parse and format functions
-// Here is a sample implementation using moment.js
-validate.extend(validate.validators.datetime, {
-    // The value is guaranteed not to be null or undefined but otherwise it
-    // could be anything.
-    parse: function (value) {
-        return Date.parse(value);
-    },
-    // Input is a unix timestamp
-    format: function (value, options) {
-        const dateValue = new Date(value);
-        return options.format(dateValue);
-    },
-});
-validate.validators.entries = function (value, { setSchema, entrySchema, }) {
-    const entries = Array.isArray(value) ? value : [];
-    const entryErrors = entries.reduce((errorsByIndex, entry, index) => {
-        const entryValidation = validateSingleMessageError(entry, entrySchema);
-        if (entryValidation) {
-            errorsByIndex[index] = entryValidation;
-        }
-        return errorsByIndex;
-    }, {});
-    const setErrorMessages = validate.single(value, setSchema);
-    if (!setErrorMessages && validate.isEmpty(entryErrors)) {
-        return;
-    }
-    return {
-        type: 'repeatableSet',
-        set: setErrorMessages && setErrorMessages[0],
-        entries: entryErrors,
-    };
-};
-validate.validators.nestedElements = function (value, schema) {
-    const errors = validateSingleMessageError(value || {}, schema);
-    if (!errors) {
-        return;
-    }
-    return {
-        type: 'formElements',
-        formElements: errors,
-    };
-};
-function getInvalidAttachment(value) {
-    if (value &&
-        typeof value === 'object' &&
-        value.type &&
-        value.type === 'ERROR') {
-        return value;
-    }
-}
-function validateAttachments(value) {
-    const invalidAttachmentNames = value === null || value === void 0 ? void 0 : value.reduce((invalidAttachmentNames, att) => {
-        var _a;
-        const attachmentName = (_a = getInvalidAttachment(att)) === null || _a === void 0 ? void 0 : _a.fileName;
-        if (attachmentName) {
-            invalidAttachmentNames.push(attachmentName);
-        }
-        return invalidAttachmentNames;
-    }, []);
-    if (invalidAttachmentNames === null || invalidAttachmentNames === void 0 ? void 0 : invalidAttachmentNames.length) {
-        return `${invalidAttachmentNames.join(', ')} could not be uploaded.`;
-    }
-}
-validate.validators.attachment = function (value) {
-    var _a;
-    return (_a = getInvalidAttachment(value)) === null || _a === void 0 ? void 0 : _a.errorMessage;
-};
-validate.validators.attachments = function (value) {
-    if (Array.isArray(value)) {
-        return validateAttachments(value);
-    }
-    return validateAttachments(value === null || value === void 0 ? void 0 : value.files);
-};
-// Extend validator for lookups
-validate.validators.lookups = function (value, { elementIdsWithLookupsExecuted, formElement, }) {
-    if (!formElement.isDataLookup && !formElement.isElementLookup) {
-        return;
-    }
-    // Lookups must only be executed on required form elements
-    if (formElement && !formElement.required) {
-        return;
-    }
-    if (elementIdsWithLookupsExecuted.includes(formElement.id)) {
-        return;
-    }
-    return lookupValidationMessage;
-};
-validate.validators.numberRegex = function (value, format) {
-    if (!format) {
-        return;
-    }
-    if (typeof value === 'number' && !Number.isNaN(value)) {
-        value = value.toString();
-    }
-    const errorMessages = validate.single(value, { format });
-    return errorMessages && errorMessages[0];
-};
-validate.validators.isTrue = function (value, message) {
-    if (!value) {
-        return message || 'Must be set to true';
-    }
-};
-validate.validators.needsExtension = function (value, formElement) {
-    const isValid = !Array.isArray(value) ||
-        value.every((file) => {
-            return checkFileNameExtensionIsValid(formElement, file.fileName);
-        });
-    if (!isValid)
-        return 'All files must have extensions';
-};
-function getCustomRegexFormatConfig(formElement) {
-    return formElement.regexPattern
-        ? {
-            pattern: formElement.regexPattern,
-            flags: formElement.regexFlags,
-            message: formElement.regexMessage,
-        }
-        : undefined;
-}
-export function validateSubmission(schema, submission, formElementsConditionallyShown) {
-    const formElementsValidation = validateSingleMessageError(submission, schema);
-    if (formElementsValidation) {
-        clearValidationMessagesForHiddenElements(formElementsValidation, formElementsConditionallyShown);
-        if (!validate.isEmpty(formElementsValidation)) {
-            return formElementsValidation;
-        }
-    }
-}
-const clearValidationMessagesForHiddenElements = (formElementsValidation, formElementsConditionallyShown) => {
-    // If there is no validation to check, there are no invalid elements
-    // If there is no conditionally shown elements, all invalid elements should display validation messages,
-    if (!formElementsValidation || !formElementsConditionallyShown) {
-        return;
-    }
-    for (const key in formElementsValidation) {
-        const formElementValidation = formElementsValidation[key];
-        if (!formElementValidation) {
-            continue;
-        }
-        const formElementConditionallyShown = formElementsConditionallyShown[key];
-        // If the validation is for an element that is being hidden,
-        // we can remove the validation message and move to the next validation
-        if (formElementConditionallyShown === null || formElementConditionallyShown === void 0 ? void 0 : formElementConditionallyShown.isHidden) {
-            delete formElementsValidation[key];
-            continue;
-        }
-        // If the validation is for a single element (not nested elements),
-        // we will always show the validation message
-        if (typeof formElementValidation === 'string') {
-            continue;
-        }
-        // Here we will check to see if the nested elements that are
-        // invalid are being shown, if not, remove validation messages
-        switch (formElementValidation.type) {
-            case 'repeatableSet': {
-                for (const index in formElementValidation.entries) {
-                    clearValidationMessagesForHiddenElements(formElementValidation.entries[index], formElementConditionallyShown &&
-                        formElementConditionallyShown.type === 'repeatableSet'
-                        ? formElementConditionallyShown.entries[index]
-                        : undefined);
-                    if (validate.isEmpty(formElementValidation.entries[index])) {
-                        delete formElementValidation.entries[index];
-                    }
-                }
-                // Remove the validation if all entries are valid and the set is also valid
-                if (validate.isEmpty(formElementValidation.entries) &&
-                    !formElementValidation.set) {
-                    delete formElementsValidation[key];
-                }
-                break;
-            }
-            case 'formElements': {
-                clearValidationMessagesForHiddenElements(formElementValidation.formElements, (formElementConditionallyShown === null || formElementConditionallyShown === void 0 ? void 0 : formElementConditionallyShown.type) === 'formElements'
-                    ? formElementConditionallyShown === null || formElementConditionallyShown === void 0 ? void 0 : formElementConditionallyShown.formElements
-                    : undefined);
-                if (validate.isEmpty(formElementValidation.formElements)) {
-                    delete formElementsValidation[key];
-                }
-                break;
-            }
-        }
-    }
-};
-const presence = ({ required, requiredMessage }, message) => (required ? { message: requiredMessage || message } : false);
-const escapeElementName = (elementName) => {
-    const escapedName = elementName.replace(/\./g, '\\.');
-    return escapedName;
-};
-export function generateValidationSchema(elements, elementIdsWithLookupsExecuted) {
-    return elements.reduce((partialSchema, formElement) => {
-        switch (formElement.type) {
-            case 'summary':
-            case 'calculation':
-            case 'image':
-            case 'html':
-            case 'infoPage':
-            case 'heading': {
-                break;
-            }
-            case 'section':
-            case 'page': {
-                const nestedSchema = generateValidationSchema(formElement.elements, elementIdsWithLookupsExecuted);
-                Object.assign(partialSchema, nestedSchema);
-                break;
-            }
-            case 'draw': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    attachment: true,
-                    presence: presence(formElement, 'A signature is required'),
-                };
-                break;
-            }
-            case 'camera': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    attachment: true,
-                    presence: presence(formElement, 'A photo is required'),
-                };
-                break;
-            }
-            case 'captcha': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence({ ...formElement, required: true }, 'Please complete the CAPTCHA successfully'),
-                };
-                break;
-            }
-            case 'location': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Please select a location'),
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                };
-                break;
-            }
-            case 'compliance': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Required'),
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                    attachments: true,
-                };
-                break;
-            }
-            case 'abn':
-            case 'geoscapeAddress':
-            case 'pointAddress':
-            case 'civicaStreetName':
-            case 'autocomplete':
-            case 'checkboxes':
-            case 'radio':
-            case 'select': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Required'),
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                };
-                break;
-            }
-            case 'boolean': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    isTrue: formElement.required && 'Required',
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                };
-                break;
-            }
-            case 'bsb': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Please enter a BSB number'),
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                    format: {
-                        pattern: /\d{3}-\d{3}/,
-                        message: 'Please enter a valid BSB number',
-                    },
-                };
-                break;
-            }
-            case 'barcodeScanner': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Please scan a barcode or enter a value'),
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                    format: getCustomRegexFormatConfig(formElement),
-                };
-                break;
-            }
-            case 'text':
-            case 'textarea': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Please enter a value'),
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                    length: {
-                        minimum: formElement.minLength,
-                        tooShort: 'Please enter a value with at least %{count} character(s)',
-                        maximum: formElement.maxLength,
-                        tooLong: 'Please enter a value with %{count} character(s) or less',
-                    },
-                    format: getCustomRegexFormatConfig(formElement),
-                };
-                break;
-            }
-            case 'telephone': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Please enter a phone number'),
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                    format: getCustomRegexFormatConfig(formElement),
-                };
-                break;
-            }
-            case 'email': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Please enter an email address'),
-                    email: {
-                        message: 'Please enter a valid email for this field',
-                    },
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                    format: getCustomRegexFormatConfig(formElement),
-                };
-                break;
-            }
-            case 'time': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Please select a time'),
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                };
-                break;
-            }
-            case 'date': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Please select a date'),
-                    date: {
-                        format: (v) => localisationService.formatDate(v),
-                        earliest: parseDateValue({
-                            dateOnly: true,
-                            daysOffset: formElement.fromDateDaysOffset,
-                            value: formElement.fromDate,
-                        }),
-                        latest: parseDateValue({
-                            dateOnly: true,
-                            daysOffset: formElement.toDateDaysOffset,
-                            value: formElement.toDate,
-                        }),
-                        notValid: 'Please select a valid date',
-                        tooEarly: 'Date cannot be before %{date}',
-                        tooLate: 'Date cannot be after %{date}',
-                    },
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                };
-                break;
-            }
-            case 'datetime': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: presence(formElement, 'Please select a date and time'),
-                    datetime: {
-                        format: (v) => localisationService.formatDatetime(v),
-                        earliest: parseDateValue({
-                            dateOnly: false,
-                            daysOffset: formElement.fromDateDaysOffset,
-                            value: formElement.fromDate,
-                        }),
-                        latest: parseDateValue({
-                            dateOnly: false,
-                            daysOffset: formElement.toDateDaysOffset,
-                            value: formElement.toDate,
-                        }),
-                        notValid: 'Please select a valid date and time',
-                        tooEarly: 'Date and time cannot be before %{date}',
-                        tooLate: 'Date and time cannot be after %{date}',
-                    },
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                };
-                break;
-            }
-            case 'number': {
-                let minErrorMessage = 'Please enter a number greater than or equal to %{count}';
-                let maxErrorMessage = 'Please enter a number less than or equal to %{count}';
-                if (typeof formElement.minNumber === 'number' &&
-                    typeof formElement.maxNumber === 'number') {
-                    minErrorMessage =
-                        maxErrorMessage = `Please enter a number between ${formElement.minNumber} and ${formElement.maxNumber}`;
-                }
-                partialSchema[escapeElementName(formElement.name)] = {
-                    type: 'number',
-                    presence: presence(formElement, 'Please enter a number'),
-                    numericality: {
-                        greaterThanOrEqualTo: formElement.minNumber,
-                        notGreaterThanOrEqualTo: minErrorMessage,
-                        lessThanOrEqualTo: formElement.maxNumber,
-                        notLessThanOrEqualTo: maxErrorMessage,
-                        onlyInteger: formElement.isInteger,
-                        notInteger: 'Please enter a whole number',
-                    },
-                    lookups: {
-                        formElement,
-                        elementIdsWithLookupsExecuted,
-                    },
-                    numberRegex: getCustomRegexFormatConfig(formElement),
-                };
-                break;
-            }
-            case 'files': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    presence: formElement.minEntries
-                        ? {
-                            message: `Please upload at least ${formElement.minEntries} file${formElement.minEntries === 1 ? '' : 's'}`,
-                        }
-                        : false,
-                    length: {
-                        minimum: formElement.minEntries,
-                        maximum: formElement.maxEntries,
-                        tooLong: 'Cannot upload more than %{count} file(s)',
-                        tooShort: 'Please upload at least %{count} file(s)',
-                    },
-                    type: {
-                        type: (files) => {
-                            return (!Array.isArray(files) ||
-                                files.every((file) => {
-                                    return checkFileNameIsValid(formElement, file.fileName);
-                                }));
-                        },
-                        message: `Only the following file types are accepted: ${(formElement.restrictedFileTypes || []).join(', ')}`,
-                    },
-                    needsExtension: formElement,
-                    attachments: true,
-                };
-                break;
-            }
-            case 'repeatableSet': {
-                partialSchema[escapeElementName(formElement.name)] = {
-                    entries: {
-                        setSchema: {
-                            presence: formElement.minSetEntries
-                                ? {
-                                    message: `Must have at least ${formElement.minSetEntries} ${formElement.minSetEntries === 1 ? 'entry' : 'entries'}`,
-                                }
-                                : false,
-                            length: {
-                                minimum: formElement.minSetEntries,
-                                maximum: formElement.maxSetEntries,
-                                tooLong: 'Cannot have more than %{count} entry/entries',
-                                tooShort: 'Must have at least %{count} entry/entries',
-                            },
-                        },
-                        entrySchema: generateValidationSchema(formElement.elements, elementIdsWithLookupsExecuted),
-                    },
-                };
-                break;
-            }
-            case 'civicaNameRecord': {
-                const nestedElements = generateCivicaNameRecordElements(formElement, []);
-                partialSchema[escapeElementName(formElement.name)] = {
-                    nestedElements: generateValidationSchema(nestedElements, elementIdsWithLookupsExecuted),
-                };
-                break;
-            }
-            case 'form': {
-                if (formElement.elements) {
-                    partialSchema[escapeElementName(formElement.name)] = {
-                        nestedElements: generateValidationSchema(formElement.elements, elementIdsWithLookupsExecuted),
-                    };
-                }
-                break;
-            }
-            case 'freshdeskDependentField': {
-                const nestedElements = generateFreshdeskDependentFieldElements(formElement, undefined);
-                partialSchema[escapeElementName(formElement.name)] = {
-                    nestedElements: generateValidationSchema(nestedElements, elementIdsWithLookupsExecuted),
-                };
-                break;
-            }
-            default: {
-                console.info('Unsupported form element with validation', formElement);
-            }
-        }
-        return partialSchema;
-    }, {});
-}
-const validateSingleMessageError = (submission, schema) => {
-    const errorsAsArray = validate(submission, schema, {
-        format: 'grouped',
-        fullMessages: false,
-    });
-    if (!errorsAsArray || validate.isEmpty(errorsAsArray)) {
-        return;
-    }
-    const errors = Object.keys(errorsAsArray || {}).reduce((messagesByFormElementName, key) => {
-        const validationMessage = errorsAsArray[key][0];
-        if (validationMessage) {
-            messagesByFormElementName[key.replace(/\\./g, '.')] = validationMessage;
-        }
-        return messagesByFormElementName;
-    }, {});
-    if (validate.isEmpty(errors)) {
-        return;
-    }
-    return errors;
-};
-export function checkFileNameIsValid(formElement, fileName) {
-    const extension = fileName.split('.').pop();
-    return (!formElement.restrictedFileTypes ||
-        formElement.restrictedFileTypes.some((fileType) => fileType.toLowerCase() === (extension === null || extension === void 0 ? void 0 : extension.toLowerCase())));
-}
-export function checkFileNameExtensionIsValid(formElement, fileName) {
-    return (formElement.allowExtensionlessAttachments || fileName.split('.').length >= 2);
-}
-export function checkSectionValidity(element, formElementsValidation) {
-    // If everything is valid, no need to check elements
-    if (!formElementsValidation) {
-        return false;
-    }
-    // If there is no elements on the page that are invalid, we will treat as valid
-    return element.elements.some((formElement) => {
-        switch (formElement.type) {
-            case 'page':
-            case 'section': {
-                return checkSectionValidity(formElement, formElementsValidation);
-            }
-            default: {
-                return formElementsValidation[formElement.name];
-            }
-        }
-    });
-}
+import validate from 'validate.js';
+import { localisationService } from '@oneblink/apps';
+import { parseDateValue } from './generate-default-data';
+import generateCivicaNameRecordElements from './generateCivicaNameRecordElements';
+import generateFreshdeskDependentFieldElements from './generateFreshdeskDependentFieldElements';
+export const lookupValidationMessage = 'Lookup is required';
+// https://validatejs.org/#validators-datetime
+// Before using it we must add the parse and format functions
+// Here is a sample implementation using moment.js
+validate.extend(validate.validators.datetime, {
+    // The value is guaranteed not to be null or undefined but otherwise it
+    // could be anything.
+    parse: function (value) {
+        return Date.parse(value);
+    },
+    // Input is a unix timestamp
+    format: function (value, options) {
+        const dateValue = new Date(value);
+        return options.format(dateValue);
+    },
+});
+validate.validators.entries = function (value, { setSchema, entrySchema, }) {
+    const entries = Array.isArray(value) ? value : [];
+    const entryErrors = entries.reduce((errorsByIndex, entry, index) => {
+        const entryValidation = validateSingleMessageError(entry, entrySchema);
+        if (entryValidation) {
+            errorsByIndex[index] = entryValidation;
+        }
+        return errorsByIndex;
+    }, {});
+    const setErrorMessages = validate.single(value, setSchema);
+    if (!setErrorMessages && validate.isEmpty(entryErrors)) {
+        return;
+    }
+    return {
+        type: 'repeatableSet',
+        set: setErrorMessages && setErrorMessages[0],
+        entries: entryErrors,
+    };
+};
+validate.validators.nestedElements = function (value, schema) {
+    const errors = validateSingleMessageError(value || {}, schema);
+    if (!errors) {
+        return;
+    }
+    return {
+        type: 'formElements',
+        formElements: errors,
+    };
+};
+function getInvalidAttachment(value) {
+    if (value &&
+        typeof value === 'object' &&
+        value.type &&
+        value.type === 'ERROR') {
+        return value;
+    }
+}
+function validateAttachments(value) {
+    const invalidAttachmentNames = value === null || value === void 0 ? void 0 : value.reduce((invalidAttachmentNames, att) => {
+        var _a;
+        const attachmentName = (_a = getInvalidAttachment(att)) === null || _a === void 0 ? void 0 : _a.fileName;
+        if (attachmentName) {
+            invalidAttachmentNames.push(attachmentName);
+        }
+        return invalidAttachmentNames;
+    }, []);
+    if (invalidAttachmentNames === null || invalidAttachmentNames === void 0 ? void 0 : invalidAttachmentNames.length) {
+        return `${invalidAttachmentNames.join(', ')} could not be uploaded.`;
+    }
+}
+validate.validators.attachment = function (value) {
+    var _a;
+    return (_a = getInvalidAttachment(value)) === null || _a === void 0 ? void 0 : _a.errorMessage;
+};
+validate.validators.attachments = function (value) {
+    if (Array.isArray(value)) {
+        return validateAttachments(value);
+    }
+    return validateAttachments(value === null || value === void 0 ? void 0 : value.files);
+};
+// Extend validator for lookups
+validate.validators.lookups = function (value, { elementIdsWithLookupsExecuted, formElement, }) {
+    if (!formElement.isDataLookup && !formElement.isElementLookup) {
+        return;
+    }
+    // Lookups must only be executed on required form elements
+    if (formElement && !formElement.required) {
+        return;
+    }
+    if (elementIdsWithLookupsExecuted.includes(formElement.id)) {
+        return;
+    }
+    return lookupValidationMessage;
+};
+validate.validators.numberRegex = function (value, format) {
+    if (!format) {
+        return;
+    }
+    if (typeof value === 'number' && !Number.isNaN(value)) {
+        value = value.toString();
+    }
+    const errorMessages = validate.single(value, { format });
+    return errorMessages && errorMessages[0];
+};
+validate.validators.isTrue = function (value, message) {
+    if (!value) {
+        return message || 'Must be set to true';
+    }
+};
+validate.validators.needsExtension = function (value, formElement) {
+    const isValid = !Array.isArray(value) ||
+        value.every((file) => {
+            return checkFileNameExtensionIsValid(formElement, file.fileName);
+        });
+    if (!isValid)
+        return 'All files must have extensions';
+};
+function getCustomRegexFormatConfig(formElement) {
+    return formElement.regexPattern
+        ? {
+            pattern: formElement.regexPattern,
+            flags: formElement.regexFlags,
+            message: formElement.regexMessage,
+        }
+        : undefined;
+}
+export function validateSubmission(schema, submission, formElementsConditionallyShown) {
+    const formElementsValidation = validateSingleMessageError(submission, schema);
+    if (formElementsValidation) {
+        clearValidationMessagesForHiddenElements(formElementsValidation, formElementsConditionallyShown);
+        if (!validate.isEmpty(formElementsValidation)) {
+            return formElementsValidation;
+        }
+    }
+}
+const clearValidationMessagesForHiddenElements = (formElementsValidation, formElementsConditionallyShown) => {
+    // If there is no validation to check, there are no invalid elements
+    // If there is no conditionally shown elements, all invalid elements should display validation messages,
+    if (!formElementsValidation || !formElementsConditionallyShown) {
+        return;
+    }
+    for (const key in formElementsValidation) {
+        const formElementValidation = formElementsValidation[key];
+        if (!formElementValidation) {
+            continue;
+        }
+        const formElementConditionallyShown = formElementsConditionallyShown[key];
+        // If the validation is for an element that is being hidden,
+        // we can remove the validation message and move to the next validation
+        if (formElementConditionallyShown === null || formElementConditionallyShown === void 0 ? void 0 : formElementConditionallyShown.isHidden) {
+            delete formElementsValidation[key];
+            continue;
+        }
+        // If the validation is for a single element (not nested elements),
+        // we will always show the validation message
+        if (typeof formElementValidation === 'string') {
+            continue;
+        }
+        // Here we will check to see if the nested elements that are
+        // invalid are being shown, if not, remove validation messages
+        switch (formElementValidation.type) {
+            case 'repeatableSet': {
+                for (const index in formElementValidation.entries) {
+                    clearValidationMessagesForHiddenElements(formElementValidation.entries[index], formElementConditionallyShown &&
+                        formElementConditionallyShown.type === 'repeatableSet'
+                        ? formElementConditionallyShown.entries[index]
+                        : undefined);
+                    if (validate.isEmpty(formElementValidation.entries[index])) {
+                        delete formElementValidation.entries[index];
+                    }
+                }
+                // Remove the validation if all entries are valid and the set is also valid
+                if (validate.isEmpty(formElementValidation.entries) &&
+                    !formElementValidation.set) {
+                    delete formElementsValidation[key];
+                }
+                break;
+            }
+            case 'formElements': {
+                clearValidationMessagesForHiddenElements(formElementValidation.formElements, (formElementConditionallyShown === null || formElementConditionallyShown === void 0 ? void 0 : formElementConditionallyShown.type) === 'formElements'
+                    ? formElementConditionallyShown === null || formElementConditionallyShown === void 0 ? void 0 : formElementConditionallyShown.formElements
+                    : undefined);
+                if (validate.isEmpty(formElementValidation.formElements)) {
+                    delete formElementsValidation[key];
+                }
+                break;
+            }
+        }
+    }
+};
+const presence = ({ required, requiredMessage }, message) => (required ? { message: requiredMessage || message } : false);
+const escapeElementName = (elementName) => {
+    const escapedName = elementName.replace(/\./g, '\\.');
+    return escapedName;
+};
+export function generateValidationSchema(elements, elementIdsWithLookupsExecuted) {
+    return elements.reduce((partialSchema, formElement) => {
+        switch (formElement.type) {
+            case 'summary':
+            case 'calculation':
+            case 'image':
+            case 'html':
+            case 'infoPage':
+            case 'heading': {
+                break;
+            }
+            case 'section':
+            case 'page': {
+                const nestedSchema = generateValidationSchema(formElement.elements, elementIdsWithLookupsExecuted);
+                Object.assign(partialSchema, nestedSchema);
+                break;
+            }
+            case 'draw': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    attachment: true,
+                    presence: presence(formElement, 'A signature is required'),
+                };
+                break;
+            }
+            case 'camera': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    attachment: true,
+                    presence: presence(formElement, 'A photo is required'),
+                };
+                break;
+            }
+            case 'captcha': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence({ ...formElement, required: true }, 'Please complete the CAPTCHA successfully'),
+                };
+                break;
+            }
+            case 'location': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Please select a location'),
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                };
+                break;
+            }
+            case 'compliance': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Required'),
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                    attachments: true,
+                };
+                break;
+            }
+            case 'abn':
+            case 'geoscapeAddress':
+            case 'pointAddress':
+            case 'civicaStreetName':
+            case 'autocomplete':
+            case 'checkboxes':
+            case 'radio':
+            case 'select': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Required'),
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                };
+                break;
+            }
+            case 'boolean': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    isTrue: formElement.required && 'Required',
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                };
+                break;
+            }
+            case 'bsb': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Please enter a BSB number'),
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                    format: {
+                        pattern: /\d{3}-\d{3}/,
+                        message: 'Please enter a valid BSB number',
+                    },
+                };
+                break;
+            }
+            case 'barcodeScanner': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Please scan a barcode or enter a value'),
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                    format: getCustomRegexFormatConfig(formElement),
+                };
+                break;
+            }
+            case 'text':
+            case 'textarea': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Please enter a value'),
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                    length: {
+                        minimum: formElement.minLength,
+                        tooShort: 'Please enter a value with at least %{count} character(s)',
+                        maximum: formElement.maxLength,
+                        tooLong: 'Please enter a value with %{count} character(s) or less',
+                    },
+                    format: getCustomRegexFormatConfig(formElement),
+                };
+                break;
+            }
+            case 'telephone': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Please enter a phone number'),
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                    format: getCustomRegexFormatConfig(formElement),
+                };
+                break;
+            }
+            case 'email': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Please enter an email address'),
+                    email: {
+                        message: 'Please enter a valid email for this field',
+                    },
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                    format: getCustomRegexFormatConfig(formElement),
+                };
+                break;
+            }
+            case 'time': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Please select a time'),
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                };
+                break;
+            }
+            case 'date': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Please select a date'),
+                    date: {
+                        format: (v) => localisationService.formatDate(v),
+                        earliest: parseDateValue({
+                            dateOnly: true,
+                            daysOffset: formElement.fromDateDaysOffset,
+                            value: formElement.fromDate,
+                        }),
+                        latest: parseDateValue({
+                            dateOnly: true,
+                            daysOffset: formElement.toDateDaysOffset,
+                            value: formElement.toDate,
+                        }),
+                        notValid: 'Please select a valid date',
+                        tooEarly: 'Date cannot be before %{date}',
+                        tooLate: 'Date cannot be after %{date}',
+                    },
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                };
+                break;
+            }
+            case 'datetime': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: presence(formElement, 'Please select a date and time'),
+                    datetime: {
+                        format: (v) => localisationService.formatDatetime(v),
+                        earliest: parseDateValue({
+                            dateOnly: false,
+                            daysOffset: formElement.fromDateDaysOffset,
+                            value: formElement.fromDate,
+                        }),
+                        latest: parseDateValue({
+                            dateOnly: false,
+                            daysOffset: formElement.toDateDaysOffset,
+                            value: formElement.toDate,
+                        }),
+                        notValid: 'Please select a valid date and time',
+                        tooEarly: 'Date and time cannot be before %{date}',
+                        tooLate: 'Date and time cannot be after %{date}',
+                    },
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                };
+                break;
+            }
+            case 'number': {
+                let minErrorMessage = 'Please enter a number greater than or equal to %{count}';
+                let maxErrorMessage = 'Please enter a number less than or equal to %{count}';
+                if (typeof formElement.minNumber === 'number' &&
+                    typeof formElement.maxNumber === 'number') {
+                    minErrorMessage =
+                        maxErrorMessage = `Please enter a number between ${formElement.minNumber} and ${formElement.maxNumber}`;
+                }
+                partialSchema[escapeElementName(formElement.name)] = {
+                    type: 'number',
+                    presence: presence(formElement, 'Please enter a number'),
+                    numericality: {
+                        greaterThanOrEqualTo: formElement.minNumber,
+                        notGreaterThanOrEqualTo: minErrorMessage,
+                        lessThanOrEqualTo: formElement.maxNumber,
+                        notLessThanOrEqualTo: maxErrorMessage,
+                        onlyInteger: formElement.isInteger,
+                        notInteger: 'Please enter a whole number',
+                    },
+                    lookups: {
+                        formElement,
+                        elementIdsWithLookupsExecuted,
+                    },
+                    numberRegex: getCustomRegexFormatConfig(formElement),
+                };
+                break;
+            }
+            case 'files': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    presence: formElement.minEntries
+                        ? {
+                            message: `Please upload at least ${formElement.minEntries} file${formElement.minEntries === 1 ? '' : 's'}`,
+                        }
+                        : false,
+                    length: {
+                        minimum: formElement.minEntries,
+                        maximum: formElement.maxEntries,
+                        tooLong: 'Cannot upload more than %{count} file(s)',
+                        tooShort: 'Please upload at least %{count} file(s)',
+                    },
+                    type: {
+                        type: (files) => {
+                            return (!Array.isArray(files) ||
+                                files.every((file) => {
+                                    return checkFileNameIsValid(formElement, file.fileName);
+                                }));
+                        },
+                        message: `Only the following file types are accepted: ${(formElement.restrictedFileTypes || []).join(', ')}`,
+                    },
+                    needsExtension: formElement,
+                    attachments: true,
+                };
+                break;
+            }
+            case 'repeatableSet': {
+                partialSchema[escapeElementName(formElement.name)] = {
+                    entries: {
+                        setSchema: {
+                            presence: formElement.minSetEntries
+                                ? {
+                                    message: `Must have at least ${formElement.minSetEntries} ${formElement.minSetEntries === 1 ? 'entry' : 'entries'}`,
+                                }
+                                : false,
+                            length: {
+                                minimum: formElement.minSetEntries,
+                                maximum: formElement.maxSetEntries,
+                                tooLong: 'Cannot have more than %{count} entry/entries',
+                                tooShort: 'Must have at least %{count} entry/entries',
+                            },
+                        },
+                        entrySchema: generateValidationSchema(formElement.elements, elementIdsWithLookupsExecuted),
+                    },
+                };
+                break;
+            }
+            case 'civicaNameRecord': {
+                const nestedElements = generateCivicaNameRecordElements(formElement, []);
+                partialSchema[escapeElementName(formElement.name)] = {
+                    nestedElements: generateValidationSchema(nestedElements, elementIdsWithLookupsExecuted),
+                };
+                break;
+            }
+            case 'form': {
+                if (formElement.elements) {
+                    partialSchema[escapeElementName(formElement.name)] = {
+                        nestedElements: generateValidationSchema(formElement.elements, elementIdsWithLookupsExecuted),
+                    };
+                }
+                break;
+            }
+            case 'freshdeskDependentField': {
+                const nestedElements = generateFreshdeskDependentFieldElements(formElement, undefined);
+                partialSchema[escapeElementName(formElement.name)] = {
+                    nestedElements: generateValidationSchema(nestedElements, elementIdsWithLookupsExecuted),
+                };
+                break;
+            }
+            default: {
+                console.info('Unsupported form element with validation', formElement);
+            }
+        }
+        return partialSchema;
+    }, {});
+}
+const validateSingleMessageError = (submission, schema) => {
+    const errorsAsArray = validate(submission, schema, {
+        format: 'grouped',
+        fullMessages: false,
+    });
+    if (!errorsAsArray || validate.isEmpty(errorsAsArray)) {
+        return;
+    }
+    const errors = Object.keys(errorsAsArray || {}).reduce((messagesByFormElementName, key) => {
+        const validationMessage = errorsAsArray[key][0];
+        if (validationMessage) {
+            messagesByFormElementName[key.replace(/\\./g, '.')] = validationMessage;
+        }
+        return messagesByFormElementName;
+    }, {});
+    if (validate.isEmpty(errors)) {
+        return;
+    }
+    return errors;
+};
+export function checkFileNameIsValid(formElement, fileName) {
+    const extension = fileName.split('.').pop();
+    return (!formElement.restrictedFileTypes ||
+        formElement.restrictedFileTypes.some((fileType) => fileType.toLowerCase() === (extension === null || extension === void 0 ? void 0 : extension.toLowerCase())));
+}
+export function checkFileNameExtensionIsValid(formElement, fileName) {
+    return (formElement.allowExtensionlessAttachments || fileName.split('.').length >= 2);
+}
+export function checkSectionValidity(element, formElementsValidation) {
+    // If everything is valid, no need to check elements
+    if (!formElementsValidation) {
+        return false;
+    }
+    // If there is no elements on the page that are invalid, we will treat as valid
+    return element.elements.some((formElement) => {
+        switch (formElement.type) {
+            case 'page':
+            case 'section': {
+                return checkSectionValidity(formElement, formElementsValidation);
+            }
+            default: {
+                return formElementsValidation[formElement.name];
+            }
+        }
+    });
+}
 //# sourceMappingURL=form-validation.js.map