@ukhomeoffice/cop-react-form-renderer 6.15.7-alpha → 6.15.9-alpha

package/dist/components/FormRenderer/helpers/clearOutUncompletedRoutes.js

@@ -5,317 +5,207 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _mergeCollectionPages = _interopRequireDefault(require("../../../utils/CollectionPage/mergeCollectionPages"));
-var _deleteNodeByPath = _interopRequireDefault(require("./deleteNodeByPath"));
-var _Condition = _interopRequireDefault(require("../../../utils/Condition"));
+var Utils = _interopRequireWildcard(require("./clearOutUncompletedRoutesUtils"));
 var _optionIsSelected = _interopRequireDefault(require("../../../utils/Component/optionIsSelected"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /* eslint-disable no-param-reassign */
-function removeObjectWithSingleIdFieldInPlace(array) {
-  for (let i = array.length - 1; i >= 0; i -= 1) {
-    const obj = array[i];
-    if (Object.keys(obj).length === 1 && Object.keys(obj)[0] === 'id') {
-      array.splice(i, 1); // Remove the object at index i
-    }
-  }
-}
-const getImmediateParent = path => {
-  if (typeof path !== 'string' || !path.includes('.')) {
-    return null;
-  }
-  const parts = path.split('.');
-  parts.pop();
-  return parts.join('.');
-};
-
 /**
- * The nested fieldIds are placed in the payload at the same level in the heirarchy as the option question they relate to
+ *  
+ * This function recursively reads in the non-collection pages and components and builds lists from it:
+ * 
+ * 1: allComponents. This is a map of all components in the form, keyed by the fully qualified component path.
+ *      If the component belongs to a page (or other parent entity) that has its own show_when rule, then this rule
+ *      is combined with the show_when rule of the component, so the decision as to whether the component's data should
+ *      exist can be made just by processing the component.
+ *      The main purpose of this map is to allow us to build a dependency graph in the function createComponentDependenciesGraph
+ * 
+ * 2: componentsToKeep: This is an object containing a count of how many times each component is defined. This is to support the
+ *      fact that a component can be used more than once in a form (but with mutually exclusive show_when rules so only used 
+ *      once with the same path). 
+ * 
+ * @param {Array} condensedPages All pages in the form, with the collection pages collated into a single object per collection
+ * @param {Map} allCollections A map of collection objects, which are a grouping of the pages that make up a single collection  
+ * @param {Object} formData The form payload
+ * @param {Map} componentByIdMap Map of all components, to enable performant lookup by id
+ * @param {Map} componentByFieldIdMap Map of all components, to enable performant lookup by fieldId
+ * @param {Map} allComponents All components in form (including nested), keyed by path
+ * @param {Object} componentsToKeep A count of how many times each component is used, to prevent us deleting components defined > 1 times
+ * @return allComponents and componentsToKeep updated in place
  */
-const getNestedQuestionPath = (optionPath, nestedFieldId) => {
-  const parentPath = getImmediateParent(optionPath);
-  return parentPath ? "".concat(parentPath, ".").concat(nestedFieldId) : nestedFieldId;
-};
-const recursivelyMapFieldsAndDeleteHiddenNested = (page, component, path, allComponents, componentsToKeep, formData) => {
-  var _component$data;
-  // Many component, such as warnings, html and details do not have data so we can ignore them
-  if (!component.fieldId) return;
-  path = path ? "".concat(path, ".").concat(component.fieldId) : component.fieldId;
-
-  // Components can be referenced from more than one page. We need to keep track of the count of each component path, to avoid pruning paths that exist elsewhere
-  componentsToKeep[path] = (componentsToKeep[path] || 0) + 1;
-
-  // add the fully qualified path to the component, which will be required when resolving the dependencies later
-  component.path = path;
+const createComponentMapsFromForm = (condensedPages, allCollections, componentByIdMap, componentByFieldIdMap, allComponents, componentsToKeep, formData) => {
+  /*
+   * Inner function to support the recursion required to traverse through the nested structures of the form
+   */
+  const recursivelyMapFieldsAndDeleteHiddenNested = (page, component, path) => {
+    var _component$data;
+    if (!component.fieldId) return; // Many component, such as warnings, html and details do not have data so we can ignore them        
+    path = path ? "".concat(path, ".").concat(component.fieldId) : component.fieldId; // Build up the path to reflect nested components
+    componentsToKeep[path] = (componentsToKeep[path] || 0) + 1; // We need to keep track of the count of each component path, to avoid pruning paths that exist elsewhere        
+    component.path = path; // Add the fully qualified path to the component, which will be required when resolving the dependencies later
 
-  // If the parent page has a rule, this overides the component rule
-  if (page.show_when) component.show_when = page.show_when;
-
-  // this is the master repository of all components
-  allComponents.set(path, component);
-  if (component.components) {
-    component.components.forEach(c => {
-      recursivelyMapFieldsAndDeleteHiddenNested(page, c, path, allComponents, componentsToKeep, formData);
-    });
-  } else if (component !== null && component !== void 0 && (_component$data = component.data) !== null && _component$data !== void 0 && _component$data.options) {
-    var _component$data2;
-    /**
-     * Perform processing for any options, and any options containing nested questions.
-     * - set hidden nested questions when the parent option is not selected
-     * - any nested questions must be treated as components which can be shown/hidden
-     */
-    component === null || component === void 0 || (_component$data2 = component.data) === null || _component$data2 === void 0 || (_component$data2 = _component$data2.options) === null || _component$data2 === void 0 || _component$data2.forEach(option => {
-      if (option.nested) {
-        if (!(0, _optionIsSelected.default)(formData[component.id], option)) {
-          option.nested.forEach(nestedComponent => {
-            // It is safe to delete this now, as we know this data item can not be required as the associated option is not selected                     
-            (0, _deleteNodeByPath.default)(formData, getNestedQuestionPath(path, nestedComponent.fieldId));
-          });
-        } else {
-          // If the option is selected, then add any nested components to the allComponents list. If the nested block has a show_when, pass it down to the child questions
-          const blockShowWhen = option.show_when;
-          option.nested.forEach(nestedComponent => {
-            if (blockShowWhen) nestedComponent.show_when = blockShowWhen;
-            recursivelyMapFieldsAndDeleteHiddenNested(page, nestedComponent, getImmediateParent(path), allComponents, componentsToKeep, formData);
-          });
+    // If the parent page has a rule, combine it with any component rule as we will be resolving dependencies for components only
+    if (page.show_when) {
+      component.show_when = component.show_when ? [].concat(Utils.toArray(page.show_when), Utils.toArray(component.show_when)) : page.show_when;
+    }
+    Utils.addValue(path, component, allComponents); // There can be more than one component per path, so keep a map of <path, array>
+    // recurse if there is nesting
+    if (component.components) {
+      component.components.forEach(c => {
+        recursivelyMapFieldsAndDeleteHiddenNested(page, c, path, allComponents, componentsToKeep, formData);
+      });
+    } else if (component !== null && component !== void 0 && (_component$data = component.data) !== null && _component$data !== void 0 && _component$data.options) {
+      var _component$data2;
+      component === null || component === void 0 || (_component$data2 = component.data) === null || _component$data2 === void 0 || (_component$data2 = _component$data2.options) === null || _component$data2 === void 0 || _component$data2.forEach(option => {
+        if (option.nested) {
+          if (!(0, _optionIsSelected.default)(formData[component.id], option)) {
+            option.nested.forEach(nestedComponent => {
+              // delete hidden nested question payload items when the parent option is not selected
+              Utils.deleteNodeByPath(formData, Utils.getNestedQuestionPath(path, nestedComponent.fieldId));
+            });
+          } else {
+            // If the option is selected, then add any nested components to the allComponents list. If the nested block has a show_when, pass it down to the child questions                        
+            const blockShowWhen = option.show_when;
+            option.nested.forEach(nestedComponent => {
+              if (blockShowWhen) nestedComponent.show_when = blockShowWhen;
+              recursivelyMapFieldsAndDeleteHiddenNested(page, nestedComponent, Utils.getImmediateParent(path), allComponents, componentsToKeep, formData);
+            });
+          }
         }
-      }
-    });
-  }
-};
-const findShowWhenFields = (element, showWhenFields) => {
-  if (typeof element === 'object' && element !== null) {
-    if (Array.isArray(element)) {
-      element.forEach(value => {
-        findShowWhenFields(value, showWhenFields);
       });
+    }
+  };
+  // Entry point for the recursive traverse of the form specification. 
+  condensedPages === null || condensedPages === void 0 || condensedPages.forEach(page => {
+    // Make the distinction between collections (which will be processed separately) and non-collections, which will be processed here.
+    if (page.childPages) {
+      allCollections.set(page.collection.name, page);
     } else {
-      Object.keys(element).forEach(key => {
-        if (key === 'field') {
-          showWhenFields.push(element[key]);
-        }
-        findShowWhenFields(element[key], showWhenFields);
+      var _page$components;
+      (_page$components = page.components) === null || _page$components === void 0 || _page$components.forEach(useComponentInPage => {
+        const componentObj = Utils.findComponentDefinitionInForm(useComponentInPage, componentByIdMap, componentByFieldIdMap);
+        recursivelyMapFieldsAndDeleteHiddenNested(page, componentObj, null);
       });
     }
-  }
-  return showWhenFields;
-};
-function getDependencies(entity) {
-  let dependencies = null;
-  if (entity.show_when) {
-    var _findShowWhenFields;
-    // Set dependencies. Maybe multiple as show_whens can be compound and nested
-    dependencies = new Set();
-    const showWhenFields = [];
-    (_findShowWhenFields = findShowWhenFields(entity.show_when, showWhenFields)) === null || _findShowWhenFields === void 0 || _findShowWhenFields.forEach(showWhenField => {
-      dependencies.add(showWhenField);
-    });
-  }
-  return dependencies;
-}
-function addEntityToGraph(entity, componentDependencies, allDependencyRelationships) {
-  if (componentDependencies) {
-    allDependencyRelationships.set(entity.path, componentDependencies);
-  }
-}
-const recursivelyMapDependencies = (component, allDependencyRelationships) => {
-  // Non data components can be ignored - can we remove this when doing the allcomponents thing?
-  if (!component.fieldId) return;
-  const componentDependencies = getDependencies(component);
-  addEntityToGraph(component, componentDependencies, allDependencyRelationships);
-  if (component.components) {
-    component.components.forEach(c => {
-      recursivelyMapDependencies(c, allDependencyRelationships);
-    });
-  }
+  });
 };
 /**
- * Some show_when field values point to data items that are within objects provided by external calls to refdata, eg modeOfTransport.id
- * These won't map directly to the path keyed components in allComponents, so go back up levels in the path until we find the component.
- * The neighbour component might not be found at all, as the dependency might be on a field that is either provided by cop-ui (eg jobHolderStaffDetails.linemanagerEmail), 
- * or by the "addToFormData" function (eg epmsSubmitted). These will be leaf level in a dependency chain so component is not required.
+ *  
+ * This function iterates through the allComponents list. For each component, it will derive all payload paths 
+ * that this component is dependent on. The same component might be defined more than once in the form, so add the dependencies
+ * for all the component definitions.
+ * 
+ * @param {Map} allDependencyRelationships A map of each component with dependencies. The key is the fully qualified path and the value is a Set of all the paths that this component is dependent on.   
+ * @param {Map} allComponents All components in form (including nested), keyed by path. Used to build the allDependencyRelationships
+ * @return allDependencyRelationships updated in place
  */
-
-const getNeighbourObjectFromPath = (neighbourPath, allComponents) => {
-  const segments = neighbourPath.split(".");
-  for (let i = segments.length; i > 0; i -= 1) {
-    const currentPath = segments.slice(0, i).join(".");
-    const neighbour = allComponents.get(currentPath);
-    if (neighbour) return neighbour;
-  }
-  return null;
-};
-const isShowEntity = (entity, data) => {
-  var _entity$show_when;
-  // If there is no rule set, then the entity can be shown
-  if (!entity.show_when) {
-    return true;
-  }
-  if (((_entity$show_when = entity.show_when) === null || _entity$show_when === void 0 ? void 0 : _entity$show_when.type) === "or") {
-    return _Condition.default.meetsOne(entity, data);
-  }
-  return _Condition.default.meetsAll(entity, data);
-};
-const pruneSingleComponent = (formData, path, component, componentsToKeep) => {
-  // If there is more than one entry for this component, then it is being used elsewhere in a visible page. Don't prune, but reduce the count by 1
-  if (componentsToKeep[path] > 1) {
-    componentsToKeep[path] -= 1;
-  } else {
-    var _component$data3;
-    (0, _deleteNodeByPath.default)(formData, path);
-    // If the component has options, go through each option removing the data for any nested fields. Required as nested options are in the payload at the same heirarchical level.
-    if (component !== null && component !== void 0 && (_component$data3 = component.data) !== null && _component$data3 !== void 0 && _component$data3.options) {
-      var _component$data4;
-      component === null || component === void 0 || (_component$data4 = component.data) === null || _component$data4 === void 0 || (_component$data4 = _component$data4.options) === null || _component$data4 === void 0 || _component$data4.forEach(option => {
-        var _option$nested;
-        (_option$nested = option.nested) === null || _option$nested === void 0 || _option$nested.forEach(nested => {
-          (0, _deleteNodeByPath.default)(formData, getNestedQuestionPath(path, nested.fieldId));
-        });
-      });
-    }
-  }
-};
-const recursivelyResolveDependencies = (visited, dependentEntity, dependencyRelationships, form, formData, allComponents, componentsToKeep, allCollections) => {
-  if (visited.has(dependentEntity.id)) return;
-  visited.add(dependentEntity.id);
-  const neighbours = dependencyRelationships.get(dependentEntity.path);
-  neighbours === null || neighbours === void 0 || neighbours.forEach(neighbourPath => {
-    const neighbour = getNeighbourObjectFromPath(neighbourPath, allComponents);
-    if (neighbour) {
-      if (!visited.has(neighbour.id)) {
-        recursivelyResolveDependencies(visited, neighbour, dependencyRelationships, form, formData, allComponents, componentsToKeep, allCollections);
-      }
-    } else {
-      // Refactor out helper methods
-      const arrayNamePattern = /([a-zA-Z_$][\w$]*)\[\d+\]/;
-      const match = neighbourPath.match(arrayNamePattern);
-      if (match) {
-        const collectionName = match[1];
-        const collection = allCollections.get(collectionName);
-        if (collection) {
-          var _collection$childPage;
-          (_collection$childPage = collection.childPages) === null || _collection$childPage === void 0 || _collection$childPage.forEach(childPage => {
-            if (childPage.show_when) {
-              const message = "It is not possible to reliably clean hidden data when a component is dependent on a \n                            collection's data, and that collection is itself dependent on data elsewhere in the form.\n                            The dependency path is ".concat(neighbourPath, ", and the chained show_when is ").concat(JSON.stringify(childPage.show_when), ".\n                            The form will need to be changed to break this chained dependency");
-              throw new Error(message);
-            }
-            ;
-          });
+const createComponentDependenciesGraph = (allComponents, allDependencyRelationships) => {
+  allComponents === null || allComponents === void 0 || allComponents.forEach(componentArray => {
+    componentArray === null || componentArray === void 0 || componentArray.forEach(component => {
+      if (!component.fieldId) return;
+      const componentDependencies = Utils.getDependencies(component);
+      if (componentDependencies) {
+        if (allDependencyRelationships.has(component.path)) {
+          const existingSet = allDependencyRelationships.get(component.path);
+          componentDependencies.forEach(dep => existingSet.add(dep));
+        } else {
+          allDependencyRelationships.set(component.path, new Set(componentDependencies));
         }
       }
-    }
+    });
   });
-  // Whilst unravelling the recursion, we can start pruning from the leaf upwards
-  if (!isShowEntity(dependentEntity, formData)) {
-    pruneSingleComponent(formData, dependentEntity.path, dependentEntity, componentsToKeep);
-  }
-};
-const findComponentDefinitionInForm = (useComponentInPage, form) => {
-  var _ref, _form$components$find;
-  const componentInForm = (_ref = (_form$components$find = form.components.find(c => c.fieldId === useComponentInPage.use)) !== null && _form$components$find !== void 0 ? _form$components$find : form.components.find(c => c.id === useComponentInPage.use)) !== null && _ref !== void 0 ? _ref : useComponentInPage;
-  // Retun clone of component, so subsequent processing can make changes to it without changing the form
-  return JSON.parse(JSON.stringify(componentInForm));
-};
-const deleteCorrespondingMetaInfo = (component, collectionDataObject, formData) => {
-  const {
-    meta: {
-      documents
-    }
-  } = formData;
-  const fileDataBeingDeleted = collectionDataObject[component.fieldId];
-  if (!documents || !fileDataBeingDeleted) return;
-  const fileDataAsArray = Array.isArray(fileDataBeingDeleted) ? fileDataBeingDeleted : [fileDataBeingDeleted];
-  const metaDocumentIndex = documents.findIndex(document => fileDataAsArray.some(fileItem => document.url === fileItem.url));
-  if (metaDocumentIndex !== -1) {
-    documents.splice(metaDocumentIndex, 1);
-  }
 };
-const pruneCollectionEntry = (pathsToKeep, componentsToPrune, collectionDataObject, formData) => {
-  componentsToPrune.forEach(component => {
-    if (!pathsToKeep.has(component.fieldId)) {
-      var _component$data5;
-      if (component.type === "multifile") {
-        deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
-      }
-      (0, _deleteNodeByPath.default)(collectionDataObject, component.fieldId);
 
-      // REFACTOR
-      // If the component has options, go through each option removing the data for any nested fields. Required as nested options are in the payload at the same heirarchical level.
-      if (component !== null && component !== void 0 && (_component$data5 = component.data) !== null && _component$data5 !== void 0 && _component$data5.options) {
-        var _component$data6;
-        component === null || component === void 0 || (_component$data6 = component.data) === null || _component$data6 === void 0 || (_component$data6 = _component$data6.options) === null || _component$data6 === void 0 || _component$data6.forEach(option => {
-          var _option$nested2;
-          (_option$nested2 = option.nested) === null || _option$nested2 === void 0 || _option$nested2.forEach(nested => {
-            (0, _deleteNodeByPath.default)(collectionDataObject, getNestedQuestionPath(component.fieldId, nested.fieldId));
-          });
+/**
+ * 
+ * This function loops through each entry in the allDependencyRelationships map. Each entry will contain a Set of all
+ * paths that the key path is dependent on. Recursively delve into each dependency path and repeat the process until we
+ * have reached an entry that has no dependencies. At this point we can safely resolve the dependency using its show_when rule, 
+ * and unwind the recursion. 
+ * 
+ * Because all the components are inter-connected, this could result in resolving the same entry repeatedly, so keep a 'visited' 
+ * array to prevent this.
+ *   
+ * @param {Object} formData The form payload
+ * @param {Map} allComponents All components in form (including nested), keyed by path
+ * @param {Object} componentsToKeep A count of how many times each component is used, to prevent us deleting components defined > 1 times
+ * @param {Map} allDependencyRelationships A map of each component with dependencies. The key is the fully qualified path and the value is a Set of all the paths that this component is dependent on.   
+ * @param {Map} allCollections A map of collection objects, which are a grouping of the pages that make up a single collection  
+ * @param {Object} form The form specification
+ */
+const resolveComponentDependenciesGraph = (allDependencyRelationships, allComponents, componentsToKeep, allCollections, form, formData) => {
+  /*
+   * Inner function to support the recursion required to traverse through the nested nature of the allDependencyRelationships
+   */
+  const recursivelyResolveDependencies = (visited, dependentComponent, dependencyRelationships) => {
+    if (visited.has(dependentComponent)) return;
+    visited.add(dependentComponent);
+    const dependencies = dependencyRelationships.get(dependentComponent.path);
+    dependencies === null || dependencies === void 0 || dependencies.forEach(dependencyPath => {
+      const dependencyComponents = Utils.getDependencyObjectFromPath(dependencyPath, allComponents);
+      if (dependencyComponents) {
+        dependencyComponents.forEach(dependency => {
+          if (!visited.has(dependency)) {
+            recursivelyResolveDependencies(visited, dependency, dependencyRelationships);
+          }
         });
-      }
-    }
-  });
-};
-function removeEmptyArraysAndUnusedCollectionIDs(payload) {
-  if (Array.isArray(payload)) {
-    for (let i = payload.length - 1; i >= 0; i -= 1) {
-      if (Array.isArray(payload[i]) && payload[i].length === 0) {
-        payload.splice(i, 1);
       } else {
-        removeEmptyArraysAndUnusedCollectionIDs(payload[i]); // Recurse for nested structures
-      }
-    }
-  } else if (payload !== null && typeof payload === 'object') {
-    Object.keys(payload).forEach(key => {
-      if (Array.isArray(payload[key]) && payload[key].length === 0) {
-        // If the array being removed has an activeId associated with it, remove it
-        if (payload["".concat(key, "ActiveId")]) {
-          delete payload["".concat(key, "ActiveId")];
-          console.log("Deleted element : ".concat(key, "ActiveId}"));
-        }
-        delete payload["".concat(key, "ActiveId")];
-        if (payload[key]) {
-          delete payload[key];
-          console.log("Deleted element : ".concat(key));
+        // We are here if the dependency path was not found in the list of allComponents. This is valid and can happen when 
+        // a component is dependent on a field that was generated by cop-ui, e.g. jobHolderStaffDetails.linemanagerEmail.
+        // However, there is an edge case (described in the message below) that we need to validate for.  
+        const arrayNamePattern = /([a-zA-Z_$][\w$]*)\[\d+\]/;
+        const match = dependencyPath.match(arrayNamePattern);
+        if (match) {
+          const collectionName = match[1];
+          const collection = allCollections.get(collectionName);
+          if (collection) {
+            var _collection$childPage;
+            (_collection$childPage = collection.childPages) === null || _collection$childPage === void 0 || _collection$childPage.forEach(childPage => {
+              if (childPage.show_when) {
+                const message = "It is not possible to reliably clean hidden data when a component is dependent on a \n                                collection's data, and that collection is itself dependent on data elsewhere in the form.\n                                The dependency path is ".concat(dependencyPath, ", and the chained show_when is ").concat(JSON.stringify(childPage.show_when), ".\n                                The form will need to be changed to break this chained dependency");
+                throw new Error(message);
+              }
+              ;
+            });
+          }
         }
-      } else {
-        removeEmptyArraysAndUnusedCollectionIDs(payload[key]); // Recurse for nested structures
       }
     });
-  }
-}
-const clearOutUncompletedRoutes = (form, formData) => {
-  // Recurse through the whole form, building a map of all fields and their owning component id. 
-  // This is required to build the component->dependency graph in the next step, as the dependencies reference fields, not components.
-
-  const condensedPages = (0, _mergeCollectionPages.default)(form.pages);
-  const allComponents = new Map();
-  const componentsToKeep = {};
-  const allCollections = new Map();
-  condensedPages === null || condensedPages === void 0 || condensedPages.forEach(page => {
-    if (page.childPages) {
-      allCollections.set(page.collection.name, page);
-    } else {
-      var _page$components;
-      (_page$components = page.components) === null || _page$components === void 0 || _page$components.forEach(useComponentInPage => {
-        const componentObj = findComponentDefinitionInForm(useComponentInPage, form);
-        recursivelyMapFieldsAndDeleteHiddenNested(page, componentObj, null, allComponents, componentsToKeep, formData);
-      });
+    // Whilst unravelling the recursion, we can start deleting from the leaf upwards
+    if (!Utils.isShowEntity(dependentComponent, formData)) {
+      Utils.deleteComponentData(formData, dependentComponent.path, dependentComponent, componentsToKeep);
     }
-  });
-  const allDependencyRelationships = new Map();
-  allComponents === null || allComponents === void 0 || allComponents.forEach(component => {
-    recursivelyMapDependencies(component, allDependencyRelationships);
-  });
-
-  // Visit all components with 'show_whens' and resolve the dependency. Only delete the data at the leaf element, or when un-winding the recursion
-  // to deal with the edge case that an element is dependent on a data item that is hidden by a different constraint
+  };
   const visited = new Set();
-  allDependencyRelationships === null || allDependencyRelationships === void 0 || allDependencyRelationships.forEach((neighbours, dependentEntityPath) => {
-    const dependentEntity = allComponents.get(dependentEntityPath);
-    if (!visited.has(dependentEntity.id)) {
-      recursivelyResolveDependencies(visited, dependentEntity, allDependencyRelationships, form, formData, allComponents, componentsToKeep, allCollections);
-    }
+  allDependencyRelationships === null || allDependencyRelationships === void 0 || allDependencyRelationships.forEach((dependencies, dependentComponentPath) => {
+    // Each path that a component is dependent on may have > 1 possible dependent components, if a field is used twice
+    const dependentComponents = allComponents.get(dependentComponentPath);
+    dependentComponents === null || dependentComponents === void 0 || dependentComponents.forEach(dependentComponent => {
+      if (!visited.has(dependentComponent)) {
+        recursivelyResolveDependencies(visited, dependentComponent, allDependencyRelationships, form, formData, allComponents, componentsToKeep, allCollections);
+      }
+    });
   });
+};
+
+/**
+ * For each collection, iterate through the payload array's objects, and apply the collections show_when
+ * rules for each payload object.
+ * 
+ * Some of the rules may be dependent on payload items outside the collection. These will already have been cleansed
+ * so will be in a reliable state.   
+ * 
+ * @param {Map} allCollections A map of collection objects, which are a grouping of the pages that make up a single collection  
+ * @param {Object} formData The form payload
+ * @param {Map} componentByIdMap Map of all components, to enable performant lookup by id
+ * @param {Map} componentByFieldIdMap Map of all components, to enable performant lookup by fieldId
+ */
+const cleanseCollectionData = (allCollections, formData, componentByIdMap, componentByFieldIdMap) => {
   allCollections === null || allCollections === void 0 || allCollections.forEach((collection, collectionName) => {
     const collectionDataArray = formData[collectionName];
     collectionDataArray === null || collectionDataArray === void 0 || collectionDataArray.forEach(collectionDataEntry => {
@@ -327,27 +217,97 @@ const clearOutUncompletedRoutes = (form, formData) => {
       const componentsToPrune = new Map();
       (_collection$childPage2 = collection.childPages) === null || _collection$childPage2 === void 0 || _collection$childPage2.forEach(childPage => {
         var _childPage$components;
-        const showPage = isShowEntity(childPage, dataForEvaluation);
+        const showPage = Utils.isShowEntity(childPage, dataForEvaluation);
         (_childPage$components = childPage.components) === null || _childPage$components === void 0 || _childPage$components.forEach(useComponentInPage => {
-          const componentObj = findComponentDefinitionInForm(useComponentInPage, form);
-
+          const componentObj = Utils.findComponentDefinitionInForm(useComponentInPage, componentByIdMap, componentByFieldIdMap);
           // Non-data components can be ignored (eg html)
           if (!componentObj.fieldId) return;
-          const showComponentOnPage = isShowEntity(useComponentInPage, dataForEvaluation);
-          if (showPage && showComponentOnPage && isShowEntity(componentObj, dataForEvaluation)) {
-            // There may be 2 components with the same path (eg quantity in EAB2), so don't delete hidden components if they are required elsewhere
+          const showComponentOnPage = Utils.isShowEntity(useComponentInPage, dataForEvaluation);
+          if (showPage && showComponentOnPage && Utils.isShowEntity(componentObj, dataForEvaluation)) {
+            // There may be >1 components with the same path (eg quantity in EAB2), so don't delete hidden components if they are required elsewhere
             pathsToKeep.add(componentObj.fieldId);
           } else {
             componentsToPrune.set(componentObj.id, componentObj);
           }
         });
       });
-      pruneCollectionEntry(pathsToKeep, componentsToPrune, collectionDataEntry, formData);
+      Utils.pruneCollectionEntry(pathsToKeep, componentsToPrune, collectionDataEntry, formData);
     });
-    // Pruning this collection may have resulted in objects that are only left with their 'id' field, which isn't data but added by the renderer to find the activeId. If so, remove these objects
-    if (collectionDataArray) removeObjectWithSingleIdFieldInPlace(collectionDataArray);
+    // 
+    if (collectionDataArray) Utils.removeObjectWithOnlySingleIdField(collectionDataArray);
   });
-  removeEmptyArraysAndUnusedCollectionIDs(formData);
+};
+
+/**
+ * 
+ * The purpose of this function is to apply the show_when rules defined in the form specification to the 
+ * form payload (formData), and remove any data that should not be shown according to those rules.
+ * (the reason this data exists in the payload is that users can answer a question in such a way that 
+ * other questions are 'shown' to them, which are then complete. The user can then go back and change the original
+ * question to then 'hide' those questions, but the answers they gave persist in the payload. The must be cleansed
+ * before being submitted.
+ * 
+ * There are 2 types of payload data that have to be treated differently by this function for it to work.
+ * 
+ * 1. Data from non-repeating pages, containing components.
+ * 
+ * Each data item captured will be written to the payload as a field with the name of the fieldId of the payload.
+ * In the case of components that are nested within 'container' components, the payload will reflect the nesting.
+ * There is no limit to the level of nesting in a form.
+ * 
+ * To cleanse the payload for this type of data, we do the following (high level description, see method comments for detail):
+ * 
+ * - build a map of all components, keyed by their payload path (required for the next step)
+ * - for all of these components that have dependencies (show_when rules), create a graph datastructure to show all components
+ *   on which a component is dependent, and then all components that those components may be dependent on. There is no limit to 
+ *   the depth of these chained dependencies.
+ * - the reason for building a graph of these dependency chains is so we know the sequence in which we must resolve the dependencies. 
+ *   For any given chain of dependencies it is essential that we resolve the dependencies starting at the end of the chains, and work our way
+ *   back up the chain. If not, we could be resolving a dependency based on a payload item that itself will later be deleted.
+ *   Therefore, the final step is to recursively traverse the dependency graph, resolving the dependency rule for the components in 
+ *   the chain from the leaf back up to the parent node. 
+ * 
+ * 2. Page collection data
+ * 
+ * A page collection is a set of one or more pages which (as a group) can be filled in as many times is required
+ * by the user. For example, in EAB, you can add as many item-seal-details to an EAB form as are required. An item-seal-detail
+ * is made up of several different pages, all grouped. The data saved will be an array representing the whole collection, with
+ * each object in the array representing a single collection entry (a single item-seal-detail in this example).
+ * 
+ * Cleanse collection data has to be driven from the payload rather than the form, as there are repeated objects in an array
+ * representing the data. Each one has to be treated independently as the data to be cleansed can be different in each one.
+ *  
+ * - For each collection type, iterate through each payload object and treat it like an independent payload..
+ * - For each collection payload object, iterate through the collection's pages and components, and apply all the show_when rules
+ *   found at both page and component level to the payload. 
+ * - Repeat for each payload object
+ * - Repeat for all collections
+ * 
+ * @param {*} form 
+ * @param {*} formData 
+ * @returns {*} cleansed form data 
+ */
+const clearOutUncompletedRoutes = (form, formData) => {
+  // Load components into maps keyed on id and field for subsequent performant access
+  const componentByIdMap = new Map(form.components.map(c => [c.id, c]));
+  const componentByFieldIdMap = new Map(form.components.map(c => [c.fieldId, c]));
+
+  // Instantiate data structures to hold the form specification and the dependency graph   
+  const allComponents = new Map();
+  const componentsToKeep = {};
+  const allCollections = new Map();
+  const allDependencyRelationships = new Map();
+
+  // Group all pages relating to a page-collection into a single object to aid collection 
+  // processing, and to allow us to differentiate between a collection and non-collection page.
+  const condensedPages = (0, _mergeCollectionPages.default)(form.pages);
+  createComponentMapsFromForm(condensedPages, allCollections, componentByIdMap, componentByFieldIdMap, allComponents, componentsToKeep, formData);
+  createComponentDependenciesGraph(allComponents, allDependencyRelationships);
+  resolveComponentDependenciesGraph(allDependencyRelationships, allComponents, componentsToKeep, allCollections, form, formData);
+  cleanseCollectionData(allCollections, formData, componentByIdMap, componentByFieldIdMap);
+
+  // The cleansing above may have left empty arrays and collection IDs. Tidy these up.
+  Utils.removeEmptyArraysAndUnusedCollectionIDs(formData);
   return formData;
 };
 var _default = exports.default = clearOutUncompletedRoutes;