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

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

@@ -0,0 +1,502 @@
+"use strict";
+
+var Utils = _interopRequireWildcard(require("./clearOutUncompletedRoutesUtils"));
+var _Condition = _interopRequireDefault(require("../../../utils/Condition"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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; }
+describe('deleteNodeByPath', () => {
+  it('delete where node is at parent level', () => {
+    const nested = {
+      type: "Example form",
+      alpha: "alpha",
+      bravo: "bravo",
+      person: {
+        charlie: "Smith",
+        delta: "Acme Inc"
+      },
+      gamma: "gamma",
+      epsilon: "epsilon"
+    };
+    const path = 'type';
+    const result = Utils.deleteNodeByPath(nested, path);
+    expect(result).toEqual({
+      alpha: "alpha",
+      bravo: "bravo",
+      person: {
+        charlie: "Smith",
+        delta: "Acme Inc"
+      },
+      gamma: "gamma",
+      epsilon: "epsilon"
+    });
+  });
+  it('delete where node is at child level', () => {
+    const nested = {
+      type: "Example form",
+      alpha: "alpha",
+      bravo: "bravo",
+      person: {
+        charlie: "Smith",
+        delta: "Acme Inc"
+      },
+      gamma: "gamma",
+      epsilon: "epsilon"
+    };
+    const path = 'person.charlie';
+    const result = Utils.deleteNodeByPath(nested, path);
+    expect(result).toEqual({
+      type: "Example form",
+      alpha: "alpha",
+      bravo: "bravo",
+      person: {
+        delta: "Acme Inc"
+      },
+      gamma: "gamma",
+      epsilon: "epsilon"
+    });
+  });
+});
+describe('removeObjectWithSingleIdFieldInPlace', () => {
+  it('removes objects with only the "id" field', () => {
+    const inputArray = [{
+      id: 1
+    }, {
+      name: 'John'
+    }, {
+      id: 2
+    }, {
+      age: 30
+    }, {
+      id: 3
+    }, {
+      id: 4,
+      name: 'John'
+    }];
+    Utils.removeObjectWithSingleIdFieldInPlace(inputArray);
+    expect(inputArray).toEqual([{
+      name: 'John'
+    }, {
+      age: 30
+    }, {
+      id: 4,
+      name: 'John'
+    }]);
+  });
+  it('does not mutate the array if no elements are removed', () => {
+    const inputArray = [{
+      name: 'John'
+    }, {
+      age: 30
+    }];
+    const originalArray = [].concat(inputArray);
+    Utils.removeObjectWithSingleIdFieldInPlace(inputArray);
+    expect(inputArray).toEqual(originalArray);
+  });
+});
+describe('getImmediateParent', () => {
+  it('returns the immediate parent path when a valid path is provided', () => {
+    const path = 'user.profile.name';
+    const result = Utils.getImmediateParent(path);
+    expect(result).toBe('user.profile');
+  });
+  it('returns null if the path is an empty string', () => {
+    const result = Utils.getImmediateParent('');
+    expect(result).toBeNull();
+  });
+  it('returns the immediate parent when there is only one part in the path', () => {
+    const path = 'user.';
+    const result = Utils.getImmediateParent(path);
+    expect(result).toBe('user');
+  });
+});
+describe('getNestedQuestionPath', () => {
+  it('returns the correct nested path when the parent path is found', () => {
+    const result = Utils.getNestedQuestionPath('user.profile.name', 'age');
+    expect(result).toBe('user.profile.age');
+  });
+  it('returns the nestedFieldId when the parent path is not found', () => {
+    const result = Utils.getNestedQuestionPath('name', 'age');
+    expect(result).toBe('age');
+  });
+  it('handles an empty parent path correctly', () => {
+    const result = Utils.getNestedQuestionPath('', 'age');
+    expect(result).toBe('age');
+  });
+  it('handles nested paths with multiple parts correctly', () => {
+    const result = Utils.getNestedQuestionPath('user.profile.settings.theme', 'darkMode');
+    expect(result).toBe('user.profile.settings.darkMode');
+  });
+});
+describe('getDependencies', () => {
+  it('should extract "field" values from deeply nested structures', () => {
+    const input = {
+      "id": "firearms",
+      "show_when": [{
+        "type": "or",
+        "conditions": [{
+          "type": "and",
+          "conditions": [{
+            "op": "=",
+            "field": "itemCategory.category",
+            "value": "Weapons"
+          }, {
+            "op": "in",
+            "field": "itemSubCategory.epmscategory",
+            "values": ["ARM", "ARP"]
+          }]
+        }, {
+          "type": "and",
+          "conditions": [{
+            "op": "=",
+            "field": "itemCategory.category",
+            "value": "Firearms"
+          }, {
+            "op": "!=",
+            "field": "itemSubCategory.epmscategory",
+            "value": "AMM"
+          }]
+        }]
+      }]
+    };
+    expect(Utils.getDependencies(input)).toEqual(new Set(['itemCategory.category', 'itemSubCategory.epmscategory', 'itemCategory.category', 'itemSubCategory.epmscategory']));
+  });
+  it('should return null when no show_when', () => {
+    const input = {
+      "id": "firearms"
+    };
+    expect(Utils.getDependencies(input)).toEqual(null);
+  });
+});
+describe('getDependencyObjectFromPath', () => {
+  let allComponents;
+  beforeEach(() => {
+    allComponents = new Map([['whatHappened', {
+      id: 'whatHappened',
+      value: 'whatHappenedComponent'
+    }], ['modeOfTransport', {
+      id: 'modeOfTransport',
+      value: 'modeOfTransportComponent'
+    }]]);
+  });
+  it('should return the exact match from the map', () => {
+    expect(Utils.getDependencyObjectFromPath('whatHappened', allComponents)).toEqual({
+      id: 'whatHappened',
+      value: 'whatHappenedComponent'
+    });
+  });
+  it('should return the nearest parent found in the allComponents map', () => {
+    expect(Utils.getDependencyObjectFromPath('modeOfTransport.id', allComponents)).toEqual({
+      id: 'modeOfTransport',
+      value: 'modeOfTransportComponent'
+    });
+  });
+  it('should return the first matched component even when > 1 layers down', () => {
+    expect(Utils.getDependencyObjectFromPath('modeOfTransport.types.id', allComponents)).toEqual({
+      id: 'modeOfTransport',
+      value: 'modeOfTransportComponent'
+    });
+  });
+  it('should return null if no matching path is found', () => {
+    expect(Utils.getDependencyObjectFromPath('unknown.path', allComponents)).toBeNull();
+  });
+});
+jest.mock('../../../utils/Condition', () => ({
+  meetsOne: jest.fn(),
+  meetsAll: jest.fn()
+}));
+describe('isShowEntity', () => {
+  afterEach(() => {
+    jest.clearAllMocks(); // Reset mocks after each test
+  });
+  it('should return true if entity.show_when is not set', () => {
+    const entity = {}; // No show_when field
+    const data = {};
+    expect(Utils.isShowEntity(entity, data)).toBe(true);
+  });
+  it('should call meetsOne if show_when.type is "or"', () => {
+    const entity = {
+      show_when: {
+        type: 'or'
+      }
+    };
+    const data = {};
+    _Condition.default.meetsOne.mockReturnValue(true); // Mock meetsOne to return true
+
+    expect(Utils.isShowEntity(entity, data)).toBe(true);
+    expect(_Condition.default.meetsOne).toHaveBeenCalledWith(entity, data);
+    expect(_Condition.default.meetsAll).not.toHaveBeenCalled();
+  });
+  it('should call meetsAll if show_when.type is not "or"', () => {
+    const entity = {
+      show_when: {
+        type: 'and'
+      }
+    };
+    const data = {};
+    _Condition.default.meetsAll.mockReturnValue(false); // Mock meetsAll to return false
+
+    expect(Utils.isShowEntity(entity, data)).toBe(false);
+    expect(_Condition.default.meetsAll).toHaveBeenCalledWith(entity, data);
+    expect(_Condition.default.meetsOne).not.toHaveBeenCalled();
+  });
+  it('should call meetsAll if show_when.type is missing', () => {
+    const entity = {
+      show_when: {}
+    }; // No type specified
+    const data = {};
+    _Condition.default.meetsAll.mockReturnValue(true);
+    expect(Utils.isShowEntity(entity, data)).toBe(true);
+    expect(_Condition.default.meetsAll).toHaveBeenCalledWith(entity, data);
+    expect(_Condition.default.meetsOne).not.toHaveBeenCalled();
+  });
+});
+describe('findComponentDefinitionInForm', () => {
+  let componentByIdMap;
+  let componentByFieldIdMap;
+  beforeEach(() => {
+    componentByIdMap = new Map();
+    componentByFieldIdMap = new Map();
+  });
+  test('returns component from componentByIdMap when found', () => {
+    const component = {
+      id: 'comp1',
+      type: 'button'
+    };
+    componentByIdMap.set('comp1', component);
+    const pageComponentDef = {
+      use: 'comp1'
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+    expect(result).toEqual(component);
+    expect(result).not.toBe(component); // Ensure it is a clone
+  });
+  test('returns component from componentByIdMap when found, but applies show_when from pageComponentDef', () => {
+    const component = {
+      id: 'comp1',
+      type: 'button',
+      show_when: 'rule1'
+    };
+    componentByIdMap.set('comp1', component);
+    const pageComponentDef = {
+      use: 'comp1',
+      show_when: 'rule2'
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+    expect(result).toEqual({
+      id: 'comp1',
+      type: 'button',
+      show_when: 'rule2'
+    });
+  });
+  test('returns component from componentByFieldIdMap if not in componentByIdMap', () => {
+    const component = {
+      id: 'comp2',
+      type: 'input'
+    };
+    componentByFieldIdMap.set('comp2', component);
+    const pageComponentDef = {
+      use: 'comp2'
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+    expect(result).toEqual(component);
+    expect(result).not.toBe(component); // Ensure it is a clone
+  });
+  test('returns pageComponentDef if not found in either map', () => {
+    const pageComponentDef = {
+      id: 'comp1',
+      definitions: "def values"
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+    expect(result).toEqual(pageComponentDef);
+    expect(result).not.toBe(pageComponentDef); // Ensure it is a clone
+  });
+  test('ensures returned component is a deep clone', () => {
+    const component = {
+      id: 'comp3',
+      nested: {
+        key: 'value'
+      }
+    };
+    componentByIdMap.set('comp3', component);
+    const pageComponentDef = {
+      use: 'comp3'
+    };
+    const result = Utils.findComponentDefinitionInForm(pageComponentDef, componentByIdMap, componentByFieldIdMap);
+
+    // Modify the original to check deep cloning
+    component.nested.key = 'changed';
+    expect(result.nested.key).toBe('value'); // Should remain unchanged
+    expect(result).not.toBe(component); // Should not be the same reference
+  });
+});
+describe('deleteCorrespondingMetaInfo', () => {
+  let formData;
+  let collectionDataObject;
+  let component;
+  beforeEach(() => {
+    formData = {
+      meta: {
+        documents: [{
+          url: 'https://example.com/file1.pdf'
+        }, {
+          url: 'https://example.com/file2.pdf'
+        }, {
+          url: 'https://example.com/file3.pdf'
+        }]
+      }
+    };
+    collectionDataObject = {};
+    component = {
+      fieldId: 'fileField'
+    };
+  });
+  test('removes a matching document when found', () => {
+    collectionDataObject.fileField = {
+      url: 'https://example.com/file2.pdf'
+    };
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([{
+      url: 'https://example.com/file1.pdf'
+    }, {
+      url: 'https://example.com/file3.pdf'
+    }]);
+  });
+  test('removes a matching document when fileDataBeingDeleted is an array', () => {
+    collectionDataObject.fileField = [{
+      url: 'https://example.com/file2.pdf'
+    }, {
+      url: 'https://example.com/file3.pdf'
+    }];
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([{
+      url: 'https://example.com/file1.pdf'
+    }]);
+  });
+  test('does nothing if documents array is empty', () => {
+    formData.meta.documents = [];
+    collectionDataObject.fileField = {
+      url: 'https://example.com/file2.pdf'
+    };
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([]);
+  });
+  test('does nothing if fileDataBeingDeleted is undefined', () => {
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([{
+      url: 'https://example.com/file1.pdf'
+    }, {
+      url: 'https://example.com/file2.pdf'
+    }, {
+      url: 'https://example.com/file3.pdf'
+    }]);
+  });
+  test('does nothing if there is no match', () => {
+    collectionDataObject.fileField = {
+      url: 'https://example.com/nonexistent.pdf'
+    };
+    Utils.deleteCorrespondingMetaInfo(component, collectionDataObject, formData);
+    expect(formData.meta.documents).toEqual([{
+      url: 'https://example.com/file1.pdf'
+    }, {
+      url: 'https://example.com/file2.pdf'
+    }, {
+      url: 'https://example.com/file3.pdf'
+    }]);
+  });
+});
+describe("removeEmptyArraysAndUnusedCollectionIDs", () => {
+  test("removes empty arrays from an array", () => {
+    const input = [1, [], 2, []];
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual([1, 2]);
+  });
+  test("removes empty arrays from an object and deletes corresponding ActiveId", () => {
+    const input = {
+      key1: [],
+      key1ActiveId: "123",
+      key2: "value"
+    };
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual({
+      key2: "value"
+    });
+  });
+  test("removes empty arrays in nested structures", () => {
+    const input = {
+      level1: {
+        level2: {
+          arr: [],
+          arrActiveId: "456",
+          anotherKey: "data"
+        }
+      }
+    };
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual({
+      level1: {
+        level2: {
+          anotherKey: "data"
+        }
+      }
+    });
+  });
+  test("removes multiple empty arrays and their ActiveIds", () => {
+    const input = {
+      list1: [],
+      list1ActiveId: "789",
+      list2: [1, 2],
+      nested: {
+        emptyList: [],
+        emptyListActiveId: "999"
+      }
+    };
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual({
+      list2: [1, 2],
+      nested: {}
+    });
+  });
+  test("does not modify non-empty arrays", () => {
+    const input = {
+      arr: [1, 2, 3],
+      obj: {
+        nestedArr: ["a"]
+      }
+    };
+    const expected = {
+      arr: [1, 2, 3],
+      obj: {
+        nestedArr: ["a"]
+      }
+    };
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual(expected);
+  });
+  test("handles null and empty object gracefully", () => {
+    const input1 = null;
+    const input2 = {};
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input1);
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input2);
+    expect(input1).toBeNull();
+    expect(input2).toEqual({});
+  });
+  test("handles arrays containing objects with empty arrays", () => {
+    const input = [{
+      key: []
+    }, {
+      key: "value"
+    }, {
+      nested: {
+        arr: [],
+        arrActiveId: "555"
+      }
+    }];
+    Utils.removeEmptyArraysAndUnusedCollectionIDs(input);
+    expect(input).toEqual([{
+      key: "value"
+    }, {
+      nested: {}
+    }]);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ukhomeoffice/cop-react-form-renderer",
-  "version": "6.15.7-alpha",
+  "version": "6.15.8-alpha",
   "private": false,
   "scripts": {
     "clean": "rimraf dist",

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

@@ -1,29 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-/* eslint-disable consistent-return */
-const deleteNodeByPath = (obj, path) => {
-  if (Array.isArray(obj)) {
-    // If obj is an array, recursively call deleteNodeByPath on each element
-    for (let i = 0; i < obj.length; i += 1) {
-      deleteNodeByPath(obj[i], path);
-    }
-  }
-  const keys = path.split('.');
-  let current = obj;
-  for (let i = 0; i < keys.length - 1; i += 1) {
-    current = current[keys[i]];
-    if (current === undefined) {
-      return;
-    }
-  }
-  if (current[keys[keys.length - 1]]) {
-    console.log("Deleting element : ".concat(keys[keys.length - 1]));
-    delete current[keys[keys.length - 1]];
-  }
-  return obj;
-};
-var _default = exports.default = deleteNodeByPath;

package/dist/components/FormRenderer/helpers/deleteNodeByPath.test.js

@@ -1,56 +0,0 @@
-"use strict";
-
-var _deleteNodeByPath = _interopRequireDefault(require("./deleteNodeByPath"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-describe('Delete node based on path', () => {
-  it('delete where node is at parent level', () => {
-    const nested = {
-      type: "Example form",
-      alpha: "alpha",
-      bravo: "bravo",
-      person: {
-        charlie: "Smith",
-        delta: "Acme Inc"
-      },
-      gamma: "gamma",
-      epsilon: "epsilon"
-    };
-    const path = 'type';
-    const result = (0, _deleteNodeByPath.default)(nested, path);
-    expect(result).toEqual({
-      alpha: "alpha",
-      bravo: "bravo",
-      person: {
-        charlie: "Smith",
-        delta: "Acme Inc"
-      },
-      gamma: "gamma",
-      epsilon: "epsilon"
-    });
-  });
-  it('delete where node is at child level', () => {
-    const nested = {
-      type: "Example form",
-      alpha: "alpha",
-      bravo: "bravo",
-      person: {
-        charlie: "Smith",
-        delta: "Acme Inc"
-      },
-      gamma: "gamma",
-      epsilon: "epsilon"
-    };
-    const path = 'person.charlie';
-    const result = (0, _deleteNodeByPath.default)(nested, path);
-    expect(result).toEqual({
-      type: "Example form",
-      alpha: "alpha",
-      bravo: "bravo",
-      person: {
-        delta: "Acme Inc"
-      },
-      gamma: "gamma",
-      epsilon: "epsilon"
-    });
-  });
-});