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

package/dist/services/checkIfAttachmentsAreUploading.js

@@ -1,58 +1,58 @@
-function checkIfAttachmentsAreUploadingForFormElements(formElements, submission) {
-    return formElements.some((formElement) => {
-        var _a;
-        switch (formElement.type) {
-            case 'section':
-            case 'page': {
-                return checkIfAttachmentsAreUploadingForFormElements(formElement.elements, submission);
-            }
-            case 'form': {
-                const nestedSubmission = submission[formElement.name];
-                if (!nestedSubmission || typeof nestedSubmission !== 'object') {
-                    break;
-                }
-                return checkIfAttachmentsAreUploadingForFormElements(formElement.elements || [], nestedSubmission);
-            }
-            case 'repeatableSet': {
-                const entries = submission[formElement.name];
-                if (!Array.isArray(entries)) {
-                    break;
-                }
-                return entries.some((entry) => {
-                    return (typeof entry === 'object' &&
-                        checkIfAttachmentsAreUploadingForFormElements(formElement.elements, entry));
-                });
-            }
-            case 'camera':
-            case 'draw':
-            case 'compliance':
-            case 'files': {
-                const value = submission[formElement.name];
-                if (!value) {
-                    break;
-                }
-                // If the attachment has a type, it has not finished uploading
-                switch (formElement.type) {
-                    case 'camera':
-                    case 'draw': {
-                        return !!(value === null || value === void 0 ? void 0 : value.type);
-                    }
-                    case 'compliance': {
-                        return (_a = value.files) === null || _a === void 0 ? void 0 : _a.some((file) => {
-                            return !!(file === null || file === void 0 ? void 0 : file.type);
-                        });
-                    }
-                    case 'files': {
-                        return value === null || value === void 0 ? void 0 : value.some((attachment) => {
-                            return !!(attachment === null || attachment === void 0 ? void 0 : attachment.type);
-                        });
-                    }
-                }
-            }
-        }
-    });
-}
-export default function checkIfAttachmentsAreUploading(form, submission) {
-    return checkIfAttachmentsAreUploadingForFormElements(form.elements, submission);
-}
+function checkIfAttachmentsAreUploadingForFormElements(formElements, submission) {
+    return formElements.some((formElement) => {
+        var _a;
+        switch (formElement.type) {
+            case 'section':
+            case 'page': {
+                return checkIfAttachmentsAreUploadingForFormElements(formElement.elements, submission);
+            }
+            case 'form': {
+                const nestedSubmission = submission[formElement.name];
+                if (!nestedSubmission || typeof nestedSubmission !== 'object') {
+                    break;
+                }
+                return checkIfAttachmentsAreUploadingForFormElements(formElement.elements || [], nestedSubmission);
+            }
+            case 'repeatableSet': {
+                const entries = submission[formElement.name];
+                if (!Array.isArray(entries)) {
+                    break;
+                }
+                return entries.some((entry) => {
+                    return (typeof entry === 'object' &&
+                        checkIfAttachmentsAreUploadingForFormElements(formElement.elements, entry));
+                });
+            }
+            case 'camera':
+            case 'draw':
+            case 'compliance':
+            case 'files': {
+                const value = submission[formElement.name];
+                if (!value) {
+                    break;
+                }
+                // If the attachment has a type, it has not finished uploading
+                switch (formElement.type) {
+                    case 'camera':
+                    case 'draw': {
+                        return !!(value === null || value === void 0 ? void 0 : value.type);
+                    }
+                    case 'compliance': {
+                        return (_a = value.files) === null || _a === void 0 ? void 0 : _a.some((file) => {
+                            return !!(file === null || file === void 0 ? void 0 : file.type);
+                        });
+                    }
+                    case 'files': {
+                        return value === null || value === void 0 ? void 0 : value.some((attachment) => {
+                            return !!(attachment === null || attachment === void 0 ? void 0 : attachment.type);
+                        });
+                    }
+                }
+            }
+        }
+    });
+}
+export default function checkIfAttachmentsAreUploading(form, submission) {
+    return checkIfAttachmentsAreUploadingForFormElements(form.elements, submission);
+}
 //# sourceMappingURL=checkIfAttachmentsAreUploading.js.map

package/dist/services/checkIfAttachmentsExist.d.ts

@@ -1,5 +1,5 @@
-import { FormTypes } from '@oneblink/types';
-import { Attachment, AttachmentError } from '../types/attachments';
-import { FormSubmissionModel } from '../types/form';
-export declare function validateAttachmentExists(attachment: Attachment, attachmentRetentionInDays: number | undefined): AttachmentError | void;
-export default function checkIfAttachmentsExist(form: FormTypes.Form, submission: FormSubmissionModel, attachmentRetentionInDays: number | undefined): FormSubmissionModel | void;
+import { FormTypes } from '@oneblink/types';
+import { Attachment, AttachmentError } from '../types/attachments';
+import { FormSubmissionModel } from '../types/form';
+export declare function validateAttachmentExists(attachment: Attachment, attachmentRetentionInDays: number | undefined): AttachmentError | void;
+export default function checkIfAttachmentsExist(form: FormTypes.Form, submission: FormSubmissionModel, attachmentRetentionInDays: number | undefined): FormSubmissionModel | void;

package/dist/services/checkIfAttachmentsExist.js

@@ -1,145 +1,145 @@
-import { v4 as uuid } from 'uuid';
-export function validateAttachmentExists(attachment, attachmentRetentionInDays) {
-    if (attachment.type || !attachment.uploadedAt || !attachmentRetentionInDays) {
-        return;
-    }
-    const uploadedAt = new Date(attachment.uploadedAt);
-    const expiresAt = new Date(attachment.uploadedAt);
-    expiresAt.setDate(uploadedAt.getDate() + attachmentRetentionInDays);
-    const now = new Date();
-    console.log('Checking if attachment still exists', {
-        uploadedAt,
-        expiresAt,
-        attachment,
-    });
-    // check if attachment exists
-    if (expiresAt > now) {
-        return;
-    }
-    const attachmentError = {
-        type: 'ERROR',
-        errorMessage: "This attachment has been removed based on your administrator's data retention policy, please remove it and upload it again.",
-        _id: uuid(),
-        fileName: attachment.fileName,
-        isPrivate: attachment.isPrivate,
-    };
-    return attachmentError;
-}
-function validateAttachmentsExists(attachments, attachmentRetentionInDays) {
-    if (!Array.isArray(attachments)) {
-        return;
-    }
-    const newAttachments = [...attachments];
-    let hasChanges = false;
-    for (let index = 0; index < newAttachments.length; index++) {
-        const attachmentError = validateAttachmentExists(newAttachments[index], attachmentRetentionInDays);
-        if (attachmentError) {
-            hasChanges = true;
-            newAttachments[index] = attachmentError;
-        }
-    }
-    if (hasChanges) {
-        return newAttachments;
-    }
-}
-function checkIfAttachmentsExistForFormElements(formElements, submission, attachmentRetentionInDays) {
-    const result = {
-        ...submission,
-    };
-    let hasChanges = false;
-    for (const formElement of formElements) {
-        switch (formElement.type) {
-            case 'section':
-            case 'page': {
-                const newSubmission = checkIfAttachmentsExistForFormElements(formElement.elements, result, attachmentRetentionInDays);
-                if (newSubmission) {
-                    hasChanges = true;
-                    Object.assign(result, newSubmission);
-                }
-                break;
-            }
-            case 'form': {
-                const nestedSubmission = submission[formElement.name];
-                if (!nestedSubmission || typeof nestedSubmission !== 'object') {
-                    break;
-                }
-                const newSubmission = checkIfAttachmentsExistForFormElements(formElement.elements || [], nestedSubmission, attachmentRetentionInDays);
-                if (newSubmission) {
-                    hasChanges = true;
-                    result[formElement.name] = newSubmission;
-                }
-                break;
-            }
-            case 'repeatableSet': {
-                const entries = submission[formElement.name];
-                if (!Array.isArray(entries)) {
-                    break;
-                }
-                const newEntries = [...entries];
-                let hasEntryChanges = false;
-                for (let index = 0; index < entries.length; index++) {
-                    const entry = entries[index];
-                    if (typeof entry === 'object') {
-                        const newEntry = checkIfAttachmentsExistForFormElements(formElement.elements, entry, attachmentRetentionInDays);
-                        if (newEntry) {
-                            hasEntryChanges = true;
-                            newEntries[index] = newEntry;
-                        }
-                    }
-                }
-                if (hasEntryChanges) {
-                    hasChanges = true;
-                    result[formElement.name] = newEntries;
-                }
-                break;
-            }
-            case 'camera':
-            case 'draw':
-            case 'compliance':
-            case 'files': {
-                const value = submission[formElement.name];
-                if (!value) {
-                    break;
-                }
-                // If the attachment has a type, it has not finished uploading
-                switch (formElement.type) {
-                    case 'camera':
-                    case 'draw': {
-                        const attachmentError = validateAttachmentExists(value, attachmentRetentionInDays);
-                        if (attachmentError) {
-                            hasChanges = true;
-                            result[formElement.name] = attachmentError;
-                        }
-                        break;
-                    }
-                    case 'compliance': {
-                        const newAttachments = validateAttachmentsExists(value.files, attachmentRetentionInDays);
-                        if (newAttachments) {
-                            hasChanges = true;
-                            result[formElement.name] = {
-                                ...value,
-                                files: newAttachments,
-                            };
-                        }
-                        break;
-                    }
-                    case 'files': {
-                        const newAttachments = validateAttachmentsExists(value, attachmentRetentionInDays);
-                        if (newAttachments) {
-                            hasChanges = true;
-                            result[formElement.name] = newAttachments;
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    if (hasChanges) {
-        return result;
-    }
-}
-export default function checkIfAttachmentsExist(form, submission, attachmentRetentionInDays) {
-    return checkIfAttachmentsExistForFormElements(form.elements, submission, attachmentRetentionInDays);
-}
+import { v4 as uuid } from 'uuid';
+export function validateAttachmentExists(attachment, attachmentRetentionInDays) {
+    if (attachment.type || !attachment.uploadedAt || !attachmentRetentionInDays) {
+        return;
+    }
+    const uploadedAt = new Date(attachment.uploadedAt);
+    const expiresAt = new Date(attachment.uploadedAt);
+    expiresAt.setDate(uploadedAt.getDate() + attachmentRetentionInDays);
+    const now = new Date();
+    console.log('Checking if attachment still exists', {
+        uploadedAt,
+        expiresAt,
+        attachment,
+    });
+    // check if attachment exists
+    if (expiresAt > now) {
+        return;
+    }
+    const attachmentError = {
+        type: 'ERROR',
+        errorMessage: "This attachment has been removed based on your administrator's data retention policy, please remove it and upload it again.",
+        _id: uuid(),
+        fileName: attachment.fileName,
+        isPrivate: attachment.isPrivate,
+    };
+    return attachmentError;
+}
+function validateAttachmentsExists(attachments, attachmentRetentionInDays) {
+    if (!Array.isArray(attachments)) {
+        return;
+    }
+    const newAttachments = [...attachments];
+    let hasChanges = false;
+    for (let index = 0; index < newAttachments.length; index++) {
+        const attachmentError = validateAttachmentExists(newAttachments[index], attachmentRetentionInDays);
+        if (attachmentError) {
+            hasChanges = true;
+            newAttachments[index] = attachmentError;
+        }
+    }
+    if (hasChanges) {
+        return newAttachments;
+    }
+}
+function checkIfAttachmentsExistForFormElements(formElements, submission, attachmentRetentionInDays) {
+    const result = {
+        ...submission,
+    };
+    let hasChanges = false;
+    for (const formElement of formElements) {
+        switch (formElement.type) {
+            case 'section':
+            case 'page': {
+                const newSubmission = checkIfAttachmentsExistForFormElements(formElement.elements, result, attachmentRetentionInDays);
+                if (newSubmission) {
+                    hasChanges = true;
+                    Object.assign(result, newSubmission);
+                }
+                break;
+            }
+            case 'form': {
+                const nestedSubmission = submission[formElement.name];
+                if (!nestedSubmission || typeof nestedSubmission !== 'object') {
+                    break;
+                }
+                const newSubmission = checkIfAttachmentsExistForFormElements(formElement.elements || [], nestedSubmission, attachmentRetentionInDays);
+                if (newSubmission) {
+                    hasChanges = true;
+                    result[formElement.name] = newSubmission;
+                }
+                break;
+            }
+            case 'repeatableSet': {
+                const entries = submission[formElement.name];
+                if (!Array.isArray(entries)) {
+                    break;
+                }
+                const newEntries = [...entries];
+                let hasEntryChanges = false;
+                for (let index = 0; index < entries.length; index++) {
+                    const entry = entries[index];
+                    if (typeof entry === 'object') {
+                        const newEntry = checkIfAttachmentsExistForFormElements(formElement.elements, entry, attachmentRetentionInDays);
+                        if (newEntry) {
+                            hasEntryChanges = true;
+                            newEntries[index] = newEntry;
+                        }
+                    }
+                }
+                if (hasEntryChanges) {
+                    hasChanges = true;
+                    result[formElement.name] = newEntries;
+                }
+                break;
+            }
+            case 'camera':
+            case 'draw':
+            case 'compliance':
+            case 'files': {
+                const value = submission[formElement.name];
+                if (!value) {
+                    break;
+                }
+                // If the attachment has a type, it has not finished uploading
+                switch (formElement.type) {
+                    case 'camera':
+                    case 'draw': {
+                        const attachmentError = validateAttachmentExists(value, attachmentRetentionInDays);
+                        if (attachmentError) {
+                            hasChanges = true;
+                            result[formElement.name] = attachmentError;
+                        }
+                        break;
+                    }
+                    case 'compliance': {
+                        const newAttachments = validateAttachmentsExists(value.files, attachmentRetentionInDays);
+                        if (newAttachments) {
+                            hasChanges = true;
+                            result[formElement.name] = {
+                                ...value,
+                                files: newAttachments,
+                            };
+                        }
+                        break;
+                    }
+                    case 'files': {
+                        const newAttachments = validateAttachmentsExists(value, attachmentRetentionInDays);
+                        if (newAttachments) {
+                            hasChanges = true;
+                            result[formElement.name] = newAttachments;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (hasChanges) {
+        return result;
+    }
+}
+export default function checkIfAttachmentsExist(form, submission, attachmentRetentionInDays) {
+    return checkIfAttachmentsExistForFormElements(form.elements, submission, attachmentRetentionInDays);
+}
 //# sourceMappingURL=checkIfAttachmentsExist.js.map

package/dist/services/checkIfBsbsAreValidating.d.ts

@@ -1,3 +1,3 @@
-import { FormTypes } from '@oneblink/types';
-import { FormSubmissionModel } from '../types/form';
-export default function checkIfBsbsAreValidating(form: FormTypes.Form, submission: FormSubmissionModel): boolean;
+import { FormTypes } from '@oneblink/types';
+import { FormSubmissionModel } from '../types/form';
+export default function checkIfBsbsAreValidating(form: FormTypes.Form, submission: FormSubmissionModel): boolean;

package/dist/services/checkIfBsbsAreValidating.js

@@ -1,41 +1,41 @@
-function checkIfBsbsAreValidatingForFormElements(formElements, submission) {
-    return formElements.some((formElement) => {
-        switch (formElement.type) {
-            case 'section':
-            case 'page': {
-                return checkIfBsbsAreValidatingForFormElements(formElement.elements, submission);
-            }
-            case 'form': {
-                const nestedSubmission = submission[formElement.name];
-                if (!nestedSubmission || typeof nestedSubmission !== 'object') {
-                    break;
-                }
-                return checkIfBsbsAreValidatingForFormElements(formElement.elements || [], nestedSubmission);
-            }
-            case 'repeatableSet': {
-                const entries = submission[formElement.name];
-                if (!Array.isArray(entries)) {
-                    break;
-                }
-                return entries.some((entry) => {
-                    return (typeof entry === 'object' &&
-                        checkIfBsbsAreValidatingForFormElements(formElement.elements, entry));
-                });
-            }
-            case 'bsb': {
-                const value = submission[formElement.name];
-                if (!value) {
-                    break;
-                }
-                const bsbValue = value;
-                if (typeof bsbValue === 'object') {
-                    return bsbValue.isValidating;
-                }
-            }
-        }
-    });
-}
-export default function checkIfBsbsAreValidating(form, submission) {
-    return checkIfBsbsAreValidatingForFormElements(form.elements, submission);
-}
+function checkIfBsbsAreValidatingForFormElements(formElements, submission) {
+    return formElements.some((formElement) => {
+        switch (formElement.type) {
+            case 'section':
+            case 'page': {
+                return checkIfBsbsAreValidatingForFormElements(formElement.elements, submission);
+            }
+            case 'form': {
+                const nestedSubmission = submission[formElement.name];
+                if (!nestedSubmission || typeof nestedSubmission !== 'object') {
+                    break;
+                }
+                return checkIfBsbsAreValidatingForFormElements(formElement.elements || [], nestedSubmission);
+            }
+            case 'repeatableSet': {
+                const entries = submission[formElement.name];
+                if (!Array.isArray(entries)) {
+                    break;
+                }
+                return entries.some((entry) => {
+                    return (typeof entry === 'object' &&
+                        checkIfBsbsAreValidatingForFormElements(formElement.elements, entry));
+                });
+            }
+            case 'bsb': {
+                const value = submission[formElement.name];
+                if (!value) {
+                    break;
+                }
+                const bsbValue = value;
+                if (typeof bsbValue === 'object') {
+                    return bsbValue.isValidating;
+                }
+            }
+        }
+    });
+}
+export default function checkIfBsbsAreValidating(form, submission) {
+    return checkIfBsbsAreValidatingForFormElements(form.elements, submission);
+}
 //# sourceMappingURL=checkIfBsbsAreValidating.js.map

package/dist/services/clean-form-elements-ctrl-model.d.ts

@@ -0,0 +1,4 @@
+export default function cleanFormElementsCtrlModel(formElementsCtrl: FormElementsCtrl, formElementsConditionallyShown: FormElementsConditionallyShown | undefined, stripBinaryData: boolean): {
+    model: FormElementsCtrl['model'];
+    captchaTokens: string[];
+};