@ukhomeoffice/cop-react-form-renderer 6.15.2-alpha → 6.15.2

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

@@ -0,0 +1,381 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toArray = exports.removeObjectWithOnlySingleIdField = exports.removeEmptyArraysAndUnusedCollectionIDs = exports.pruneCollectionEntry = exports.isShowEntity = exports.getNestedQuestionPath = exports.getImmediateParent = exports.getDependencyObjectFromPath = exports.getDependencies = exports.findComponentDefinitionInForm = exports.deleteNodeByPath = exports.deleteNodeAndOptions = exports.deleteCorrespondingMetaInfo = exports.deleteComponentData = exports.addValue = void 0;
+var _Condition = _interopRequireDefault(require("../../../utils/Condition"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable no-param-reassign */
+
+/**
+ * Add a value to a map of arrays. If the key exists, append the value to the array.
+ * If not, create the map entry with that key.
+ * 
+ * @param {*} key 
+ * @param {*} value 
+ * @param {*} multiMap 
+ */
+const addValue = (key, value, multiMap) => {
+  if (!multiMap.has(key)) {
+    multiMap.set(key, []);
+  }
+  multiMap.get(key).push(value);
+};
+
+/**
+ * Given a path, remove a node from this path within an object. 
+ * 
+ * @param {Object} payload Javascript object from which the node will be deleted. Updated by the method.
+ * @param {String} path A string containing a decimal point delimited path specifying the node to delete.
+ * @return {void}, obj above updated.
+ */
+exports.addValue = addValue;
+const deleteNodeByPath = (payload, path) => {
+  if (Array.isArray(payload)) {
+    // If payload is an array, recursively call deleteNodeByPath on each element
+    for (let i = 0; i < payload.length; i += 1) {
+      deleteNodeByPath(payload[i], path);
+    }
+  }
+  const keys = path.split('.');
+  let current = payload;
+  for (let i = 0; i < keys.length - 1; i += 1) {
+    current = current[keys[i]];
+    if (current === undefined) {
+      return;
+    }
+  }
+  if (current[keys[keys.length - 1]]) {
+    delete current[keys[keys.length - 1]];
+  }
+};
+
+/**
+ * Return the immediate parent of a path string passed in.
+ * Useful for processing 'options' in a form, as nested fieldIds are placed in the payload at 
+ * the same level in the heirarchy as the option question they relate to.
+ * 
+ * @param {String} path Decimal point delimited path.
+ * @returns {String} Immediate parent of the path passed in.
+ */
+exports.deleteNodeByPath = deleteNodeByPath;
+const getImmediateParent = path => {
+  if (typeof path !== 'string' || !path.includes('.')) {
+    return null;
+  }
+  const parts = path.split('.');
+  parts.pop();
+  return parts.join('.');
+};
+
+/**
+ * Questions can be nested within options, eg if you answer 'yes' to a radio question, this can 
+ * reveal additional nested questions.
+ * The path of the fields from these nested questions are at the same level as the original option
+ * answer, so this utility derives the nested question path from the option path.
+ * 
+ * @param {String} optionPath Decimal point delimited path
+ * @param {String} nestedFieldId fieldId (dataname) of the nested question within the above option
+ * @returns {String} Fully qualified path of the nested question
+ */
+exports.getImmediateParent = getImmediateParent;
+const getNestedQuestionPath = (optionPath, nestedFieldId) => {
+  const parentPath = getImmediateParent(optionPath);
+  return parentPath ? "".concat(parentPath, ".").concat(nestedFieldId) : nestedFieldId;
+};
+
+/** 
+ * 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.
+
+ * @param {Object} payload Javascript object from which the node will be deleted. Updated by the method.
+ * @param {String} path A string containing a decimal point delimited path specifying the node to delete.
+ * @param {Object} component The form component representing the path being deleted
+ * @return {void}, obj above updated.
+ */
+exports.getNestedQuestionPath = getNestedQuestionPath;
+const deleteNodeAndOptions = (payload, path, component) => {
+  var _component$data;
+  deleteNodeByPath(payload, 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$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 => {
+      var _option$nested;
+      (_option$nested = option.nested) === null || _option$nested === void 0 || _option$nested.forEach(nested => {
+        deleteNodeByPath(payload, getNestedQuestionPath(path, nested.fieldId));
+      });
+    });
+  }
+};
+
+/**
+ * Pruning a collection payload 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 entirely as they have been pruned.
+ * 
+ * @param {Array} array Array of objects. Each object which has only 1 remaining field called 'id' should be removed.
+ * @return {void}, array above updated.
+ */
+exports.deleteNodeAndOptions = deleteNodeAndOptions;
+const removeObjectWithOnlySingleIdField = 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);
+    }
+  }
+};
+
+/**
+ * Helper method to establish all the payload paths (dependencies) that an entity (page or component) is 
+ * dependent on through its show_when rule.
+ * 
+ * This will be used to build a graph of chained dependencies to establish in which order
+ * to resolve dependencies. The exact rule is not required at this point, just the dependencies.
+ * 
+ * The form specification allows complex show_when blocks including 1...n levels of nesting, so
+ * recursively search through the show_when block looking for all 'field' data items.
+ *   
+ * @param {Object} entity Entity whose show_when rule is to be searched for 'field' data items within.
+ * @returns {Set} Set of payload paths that the entity (page or component) is dependent on.
+ */
+exports.removeObjectWithOnlySingleIdField = removeObjectWithOnlySingleIdField;
+const getDependencies = entity => {
+  const findShowWhenFields = (showWhenObject, showWhenFields) => {
+    if (typeof showWhenObject === 'object' && showWhenObject !== null) {
+      if (Array.isArray(showWhenObject)) {
+        showWhenObject.forEach(value => {
+          findShowWhenFields(value, showWhenFields);
+        });
+      } else {
+        Object.keys(showWhenObject).forEach(key => {
+          if (key === 'field') {
+            showWhenFields.push(showWhenObject[key]);
+          }
+          findShowWhenFields(showWhenObject[key], showWhenFields);
+        });
+      }
+    }
+    return showWhenFields;
+  };
+  return entity.show_when ? new Set(findShowWhenFields(entity.show_when, []) || []) : null;
+};
+
+/**
+ * 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 the allComponents map, so go back up levels in the path until we find 
+ * the component that creates this field.
+ * 
+ * This 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 the dependency chain so component is not required.
+ * 
+ * @param {String} optionPath Decimal point delimited path
+ * @param {String} nestedFieldId fieldId (dataname) of the nested question within the above option
+ * @returns {String} Fully qualified path of the nested question
+ * 
+ */
+exports.getDependencies = getDependencies;
+const getDependencyObjectFromPath = (dependencyPath, allComponents) => {
+  const segments = dependencyPath.split(".");
+  for (let i = segments.length; i > 0; i -= 1) {
+    const currentPath = segments.slice(0, i).join(".");
+    const dependencyObject = allComponents.get(currentPath);
+    if (dependencyObject) return dependencyObject;
+  }
+  return null;
+};
+
+/**
+ * 
+ * Evaluate the show_when rule to establish if the component should be shown (and the 
+ * payload data should not be pruned). If there is no show_when rule, then return true.
+ *  
+ * @param {*} entity A page or component that may have a show_when rule associated with it
+ * @param {*} data The payload data used to evaluate the show_when rule
+ * @returns {boolean} true if the show_when rule evaluate to true, or there is no show_when rule
+ */
+exports.getDependencyObjectFromPath = getDependencyObjectFromPath;
+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);
+};
+
+/**
+ * 
+ * Components can be assigned to pages in 2 ways in the form specification:
+ * 
+ * 1 - They can be included in the page's components array with the 'use' field, e.g.
+ *  {
+ *      "use": "port"
+ *  }
+ * This "use" value will normally match a component's id, but can match its fieldId
+ * NB. In this case, a show_when rule can be applied here, which will supercede any show_when in the component. e.g.
+ * 
+ *  {
+ *      "use": "port",
+ *      "show_when": ....
+ *  }
+ * 
+ * 2 - The entire component can be embedded as an entry in the page's component array.
+ *   
+ * 
+ * @param {*} componentId The id of the component to find in the form. 
+ * @param {*} componentByIdMap A map of all the form's components keyed on Id, for better performance than searching the form.  
+ * @param {*} componentByFieldIdMap A map of all the form's components keyed on fieldId, for better performance than searching the form.  
+ * @returns {Object} A cloned component object, containing the full definition of that component.
+ */
+exports.isShowEntity = isShowEntity;
+const findComponentDefinitionInForm = (pageComponentDef, componentByIdMap, componentByFieldIdMap) => {
+  var _ref, _componentByIdMap$get;
+  const componentInForm = (_ref = (_componentByIdMap$get = componentByIdMap.get(pageComponentDef.use)) !== null && _componentByIdMap$get !== void 0 ? _componentByIdMap$get : componentByFieldIdMap.get(pageComponentDef.use)) !== null && _ref !== void 0 ? _ref : pageComponentDef;
+  if (pageComponentDef.use && pageComponentDef.show_when) {
+    componentInForm.show_when = pageComponentDef.show_when;
+  }
+  // Retun clone of component, so subsequent processing can make changes to it without changing the form
+  return JSON.parse(JSON.stringify(componentInForm));
+};
+
+/**
+ * 
+ * When documents are added to the payload of type multifile, they are also added to a section of the payload
+ * 'meta', specifically an array 'documents'. When we remove the multifile elements, we need to remove
+ * the corresponding meta.document entries.
+ * 
+ * @param {*} component The component definition being deleted that needs corresponding meta data also deleted
+ * @param {*} collectionDataObject The payload containing the file data being deleted (for which the corresponding meta needs deleting)
+ * @param {*} formData The entire payload, which will include the meta section
+ * @returns {void}, as the formData will be updated in situ
+ */
+exports.findComponentDefinitionInForm = findComponentDefinitionInForm;
+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];
+  // Iterate backwards to avoid index shifting when removing elements
+  for (let i = fileDataAsArray.length - 1; i >= 0; i -= 1) {
+    const matchIndex = documents.findIndex(metaDocument => metaDocument.url === fileDataAsArray[i].url);
+    if (matchIndex !== -1) {
+      documents.splice(matchIndex, 1);
+    }
+  }
+};
+
+/**
+ * After the payload has been cleansed of individual data items, empty arrays and objects may remain.
+ * Removing an array (when the payload for a collection) may leave a redundant activeId field. The active Id 
+ * fields are not part of the payload data, but added by the react renderer to track which collection object 
+ * is currently being worked on, so can be removed.
+ * 
+ * To tidy this all up, recursively empty arrays and their associated "ActiveId" fields from a nested payload.
+ *
+ * This function traverses a given payload, which can be an array or an object, and performs the following operations:
+ * 1. If an empty array is found inside an array, it is removed using `splice`.
+ * 2. If an empty array is found inside an object:
+ *    - It is removed from the object.
+ *    - If there is a corresponding `<key>ActiveId` field, that field is also removed.
+ * 3. The function operates recursively to handle deeply nested structures.
+ *
+ * @param {any} payload - The input data structure, which can be an array or an object.
+ * 
+ */
+exports.deleteCorrespondingMetaInfo = deleteCorrespondingMetaInfo;
+const 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
+      }
+      // When unwinding out of the recursion, we may have emptied an object which is the remaining element of an 
+      // array, in which case remove the element
+      if (typeof payload[i] === 'object' && Object.keys(payload[i]).length === 0) {
+        payload.splice(i, 1);
+      }
+    }
+  } 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")];
+        }
+        delete payload["".concat(key, "ActiveId")];
+        if (payload[key]) {
+          delete payload[key];
+        }
+      } else {
+        removeEmptyArraysAndUnusedCollectionIDs(payload[key]); // Recurse for nested structures
+      }
+    });
+  }
+};
+
+/**
+ * Delete a component's payload item from the overall payload.
+ * A component can be defined in >1 places in the form spec. To cater for this, 
+ * if the componentsToKeep counter tells us that there is > 1 uses of this component
+ * still unaccounted for in the form then don't delete, but reduce the count by 1.
+ * 
+ * When the counter reaches 1 we know all other occurences of the component have been resolved
+ * so it is safe to delete.
+ * 
+ * @param {*} payload The form payload from which to delete the component data
+ * @param {*} path The payload path of the component
+ * @param {*} component The component whose data we should attempt to delete
+ * @param {*} componentsToKeep A list of all components with a count of their number of uses in the form
+ */
+exports.removeEmptyArraysAndUnusedCollectionIDs = removeEmptyArraysAndUnusedCollectionIDs;
+const deleteComponentData = (payload, path, component, componentsToKeep) => {
+  if (componentsToKeep[path] > 1) {
+    componentsToKeep[path] -= 1;
+  } else {
+    deleteNodeAndOptions(payload, path, component);
+  }
+};
+
+/**
+ * 
+ * Takes a single page collection payload object and removes the payload items specified in the componentsToPrune list
+ * as long as they don't appear in the componentsToKeep list.
+ * Additionally, if the component type is multifile, remove the corresponding data entries that will have been created 
+ * in the meta section of the payload by the form renderer.
+ * 
+ * @param {Set} pathsToKeep paths that we cannot delete from the collectionDataObject
+ * @param {Map} componentsToPrune paths that we should delete, as long as they are not in the pathsToKeep
+ * @param {Object} collectionDataObject the payload from which to delete the paths
+ * @param {Object} formData The form data, whose meta section may include corresponding documents entries for multifile entries
+ */
+exports.deleteComponentData = deleteComponentData;
+const pruneCollectionEntry = (pathsToKeep, componentsToPrune, collectionDataObject, formData) => {
+  componentsToPrune.forEach(component => {
+    if (!pathsToKeep.has(component.fieldId)) {
+      if (component.type === "multifile") {
+        deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+      }
+      deleteNodeAndOptions(collectionDataObject, component.fieldId, component);
+    }
+  });
+};
+
+/*
+ * Converts an object to an array if it isn't already, for use when combining show when rules.
+ */
+exports.pruneCollectionEntry = pruneCollectionEntry;
+const toArray = value => Array.isArray(value) ? value : [value];
+exports.toArray = toArray;