@ukhomeoffice/cop-react-form-renderer 3.8.0 → 3.10.0

package/dist/models/ComponentTypes.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var TYPE_AUTOCOMPLETE = 'autocomplete';
+var TYPE_CALCULATION = 'calculation';
 var TYPE_CHECKBOXES = 'checkboxes';
 var TYPE_COLLECTION = 'collection';
 var TYPE_CONTAINER = 'container';
@@ -24,6 +25,7 @@ var TYPE_TIME = 'time';
 var TYPE_WARNING = 'warning';
 var ComponentTypes = {
   AUTOCOMPLETE: TYPE_AUTOCOMPLETE,
+  CALCULATION: TYPE_CALCULATION,
   CHECKBOXES: TYPE_CHECKBOXES,
   COLLECTION: TYPE_COLLECTION,
   CONTAINER: TYPE_CONTAINER,

package/dist/utils/Component/getComponent.js

@@ -54,6 +54,16 @@ var getCheckboxes = function getCheckboxes(config) {
   }));
 };
 
+var getCalculation = function getCalculation(config) {
+  var calculatedValue = _Data.default.applyFormula(config);
+
+  var attrs = (0, _cleanAttributes.default)(config, ['formula']);
+  return /*#__PURE__*/_react.default.createElement(_copReactComponents.TextInput, _extends({}, attrs, {
+    value: calculatedValue,
+    readOnly: true
+  }));
+};
+
 var getDate = function getDate(config) {
   var attrs = (0, _cleanAttributes.default)(config);
   return /*#__PURE__*/_react.default.createElement(_copReactComponents.DateInput, attrs);
@@ -184,6 +194,9 @@ var getComponentByType = function getComponentByType(config) {
     case _models.ComponentTypes.DETAILS:
       return getDetails(config);
 
+    case _models.ComponentTypes.CALCULATION:
+      return getCalculation(config);
+
     default:
       {
         return null;

package/dist/utils/Component/getComponentTests/getComponent.calculation.test.js

@@ -0,0 +1,269 @@
+"use strict";
+
+var _react = require("@testing-library/react");
+
+var _models = require("../../../models");
+
+var _getComponent = _interopRequireDefault(require("../getComponent"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+describe('utils.Component.get', function () {
+  var ID = 'test-id';
+  var FIELD_ID = 'field-id';
+  var LABEL = 'label';
+  var COMPONENT = {
+    type: _models.ComponentTypes.CALCULATION,
+    id: ID,
+    fieldId: FIELD_ID,
+    label: LABEL,
+    formData: {
+      totalPerson: '4',
+      personProcessed: '3'
+    },
+    'data-testid': ID
+  };
+  var error = jest.spyOn(console, 'error').mockImplementation(function () {});
+  afterAll(function () {
+    error.mockReset();
+  });
+  afterEach(function () {
+    error.mockClear();
+  });
+  /**
+   * Iteratively test collction of positive test data objects each containing:
+   *  config: object containing formula config
+   *  result: the calculated formula(s) output value.
+   *
+   * Test record structure:
+   * ----------------------
+   * {
+   *  config: {
+   *    formula: { ... }
+   *  },
+   *  result: ''
+   * }
+   * 
+   */
+
+  [{
+    config: {
+      formula: {
+        name: 'minus',
+        args: [{
+          field: 'totalPerson'
+        }, {
+          field: 'personProcessed'
+        }]
+      }
+    },
+    result: '1'
+  }, {
+    config: {
+      formula: {
+        name: 'plus',
+        args: [{
+          field: 'totalPerson'
+        }, {
+          field: 'personProcessed'
+        }]
+      }
+    },
+    result: '7'
+  }, {
+    config: {
+      formula: {
+        name: 'multiply',
+        args: [{
+          field: 'totalPerson'
+        }, {
+          field: 'personProcessed'
+        }]
+      }
+    },
+    result: '12'
+  }, {
+    config: {
+      formula: {
+        name: 'divide',
+        round: 2,
+        args: [{
+          field: 'totalPerson'
+        }, {
+          field: 'personProcessed'
+        }]
+      }
+    },
+    result: '1.33'
+  }, {
+    config: {
+      formula: {
+        name: 'multiply',
+        round: 2,
+        args: [{
+          formula: {
+            name: 'divide',
+            args: [{
+              field: 'totalPerson'
+            }, {
+              field: 'personProcessed'
+            }]
+          }
+        }, {
+          value: 200
+        }]
+      }
+    },
+    result: '266.67'
+  }].forEach(function (test) {
+    it("should render 'calculation' component with formula to given calculated value: ".concat(test.result), function () {
+      var _render = (0, _react.render)((0, _getComponent.default)(_objectSpread(_objectSpread({}, COMPONENT), test.config))),
+          container = _render.container;
+
+      var _getAllByTestId = (0, _react.getAllByTestId)(container, ID),
+          _getAllByTestId2 = _slicedToArray(_getAllByTestId, 2),
+          formGroup = _getAllByTestId2[0],
+          input = _getAllByTestId2[1];
+
+      expect(formGroup.tagName).toEqual('DIV');
+      expect(formGroup.classList).toContain('govuk-form-group');
+      var label = formGroup.childNodes[0];
+      expect(label.tagName).toEqual('LABEL');
+      expect(label.classList).toContain('govuk-label');
+      expect(label.textContent).toContain(LABEL);
+      expect(formGroup.classList).toContain('govuk-form-group');
+      expect(input.tagName).toEqual('INPUT');
+      expect(input.classList).toContain('govuk-input');
+      expect(input.id).toEqual(ID);
+      expect(input.getAttribute('readonly')).not.toBeNull();
+      expect(input.getAttribute('value')).toEqual(test.result);
+    });
+  });
+  /**
+   * Iteratively test collction of negative test data objects each containing:
+   *  config: object containing invalid formula config
+   *  result: the error to match.
+   *
+   * Test record structure:
+   * ----------------------
+   * {
+   *  config: {
+   *    formula: { ... }
+   *  },
+   *  error: 'error_message'
+   * }
+   * 
+   */
+
+  [{
+    error: "Missing 'formula' definition"
+  }, {
+    config: {
+      formula: {}
+    },
+    error: "Calculation formula 'name' cannot be empty"
+  }, {
+    config: {
+      formula: {
+        name: 'tictactoe',
+        args: [{
+          field: 'totalPerson'
+        }, {
+          field: 'personProcessed'
+        }]
+      }
+    },
+    error: "Unsupported operation 'tictactoe'"
+  }, {
+    config: {
+      formula: {
+        name: 'minus',
+        args: [{
+          field: 'totalPerson',
+          value: 100
+        }, {
+          field: 'personProcessed'
+        }]
+      }
+    },
+    error: 'Argument cannot have more than one reference'
+  }, {
+    config: {
+      formula: {
+        name: 'minus',
+        args: [{
+          newToken: 'totalPerson'
+        }, {
+          field: 'personProcessed'
+        }]
+      }
+    },
+    error: 'Only accept following as argument field: {field, value, or formula}'
+  }, {
+    config: {
+      formula: {
+        name: 'minus',
+        args: [{
+          field: 'totalPerson'
+        }]
+      }
+    },
+    error: 'Requires more than one argument for calculation'
+  }, {
+    config: {
+      formula: {
+        name: 'multiply',
+        round: 2,
+        args: [{
+          value: 200,
+          field: 'totalPerson'
+        }, {
+          value: 200
+        }]
+      }
+    },
+    error: 'Argument cannot have more than one reference'
+  }].forEach(function (test) {
+    it("should return an appropriately rendered calculation component with message ".concat(test.result), function () {
+      var _render2 = (0, _react.render)((0, _getComponent.default)(_objectSpread(_objectSpread({}, COMPONENT), test.config))),
+          container = _render2.container;
+
+      var _getAllByTestId3 = (0, _react.getAllByTestId)(container, ID),
+          _getAllByTestId4 = _slicedToArray(_getAllByTestId3, 2),
+          formGroup = _getAllByTestId4[0],
+          input = _getAllByTestId4[1];
+
+      expect(formGroup.tagName).toEqual('DIV');
+      expect(formGroup.classList).toContain('govuk-form-group');
+      var label = formGroup.childNodes[0];
+      expect(label.tagName).toEqual('LABEL');
+      expect(label.classList).toContain('govuk-label');
+      expect(label.textContent).toContain(LABEL);
+      expect(formGroup.classList).toContain('govuk-form-group');
+      expect(input.tagName).toEqual('INPUT');
+      expect(input.classList).toContain('govuk-input');
+      expect(input.id).toEqual(ID);
+      expect(input.getAttribute('readonly')).not.toBeNull();
+      expect(error).toBeCalledTimes(1);
+      expect(error).toBeCalledWith(test.error);
+    });
+  });
+});

package/dist/utils/Component/isEditable.js

@@ -8,7 +8,7 @@ exports.default = exports.EDITABLE_TYPES = void 0;
 var _models = require("../../models");
 
 // Local imports
-var EDITABLE_TYPES = [_models.ComponentTypes.AUTOCOMPLETE, _models.ComponentTypes.CHECKBOXES, _models.ComponentTypes.DATE, _models.ComponentTypes.EMAIL, _models.ComponentTypes.FILE, _models.ComponentTypes.PHONE_NUMBER, _models.ComponentTypes.RADIOS, _models.ComponentTypes.SELECT, _models.ComponentTypes.TEXT, _models.ComponentTypes.TEXT_AREA, _models.ComponentTypes.TIME];
+var EDITABLE_TYPES = [_models.ComponentTypes.AUTOCOMPLETE, _models.ComponentTypes.CALCULATION, _models.ComponentTypes.CHECKBOXES, _models.ComponentTypes.DATE, _models.ComponentTypes.EMAIL, _models.ComponentTypes.FILE, _models.ComponentTypes.PHONE_NUMBER, _models.ComponentTypes.RADIOS, _models.ComponentTypes.SELECT, _models.ComponentTypes.TEXT, _models.ComponentTypes.TEXT_AREA, _models.ComponentTypes.TIME];
 exports.EDITABLE_TYPES = EDITABLE_TYPES;
 
 var isEditable = function isEditable(options) {

package/dist/utils/Condition/meetsCondition.js

@@ -67,6 +67,11 @@ var meetsCondition = function meetsCondition(condition, value) {
           return true;
         }
 
+      case 'contains':
+        {
+          return value === null || value === void 0 ? void 0 : value.toString().toLowerCase().includes(compare); // If no value is provided, the field cannot contain it, so it must fail the condition.
+        }
+
       default:
         return false;
     }

package/dist/utils/Condition/meetsCondition.test.js

@@ -261,6 +261,95 @@ describe('utils.Condition.meetsCondition', function () {
       });
     });
   });
+  describe('operator contains', function () {
+    var op = 'contains'; // Should match...
+
+    it('should match a string that is in the field array', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a sub-string that is in the field array', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = 'alp';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a number that is in the field array', function () {
+      var FIELD = [1, 2, 3];
+      var VALUE = 1;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a sub-string that is in the field string', function () {
+      var FIELD = 'alphabravocharlie';
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    });
+    it('should match a string that is in the field array regardless of case', function () {
+      var FIELD = ['Alpha', 'bravo', 'charlie'];
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeTruthy();
+    }); // Should reject...
+
+    it('should reject a string that is missing from the field array', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject a number that is missing from the field array', function () {
+      var FIELD = [1, 2, 3];
+      var VALUE = 4;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject a substring that is missing from the field string', function () {
+      var FIELD = 'alphabravocharlie';
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any value when the field is an empty Array', function () {
+      var FIELD = [];
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any value when the field is an empty string', function () {
+      var FIELD = '';
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any field when the value is null', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = null;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any field when the value is undefined', function () {
+      var FIELD = ['alpha', 'bravo', 'charlie'];
+      var VALUE = undefined;
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any value when the field is null', function () {
+      var FIELD = null;
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+    it('should reject any value when the field is undefined', function () {
+      var FIELD = undefined;
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, VALUE);
+      expect((0, _meetsCondition.default)(CONDITION, FIELD)).toBeFalsy();
+    });
+  });
   describe('unknown operator', function () {
     var op = 'definitely_not_a_real_operator';
     it('should reject anything regardless of the value', function () {

package/dist/utils/Data/applyFormula.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _copReactComponents = require("@ukhomeoffice/cop-react-components");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var applyFormula = function applyFormula(config) {
+  try {
+    var result = simplify(config);
+    return !result && result !== 0 ? '' : result;
+  } catch (err) {
+    console.error(err.message);
+  }
+
+  return '';
+};
+
+var simplify = function simplify(config) {
+  if (!config || !config.formula) {
+    throw new Error("Missing 'formula' definition");
+  }
+
+  var _config$formula = _objectSpread({}, config.formula),
+      name = _config$formula.name;
+
+  switch (name) {
+    case 'multiply':
+      return reduceNumber(config, function (t, c) {
+        return t * c;
+      });
+
+    case 'divide':
+      return reduceNumber(config, function (t, c) {
+        return t / c;
+      });
+
+    case 'plus':
+      return reduceNumber(config, function (t, c) {
+        return t + c;
+      });
+
+    case 'minus':
+      return reduceNumber(config, function (t, c) {
+        return t - c;
+      });
+
+    default:
+      throw new Error(!name ? "Calculation formula 'name' cannot be empty" : "Unsupported operation '".concat(name, "'"));
+  }
+};
+
+var reduceNumber = function reduceNumber(config, reduction) {
+  var _config$formula2 = _objectSpread({}, config.formula),
+      args = _config$formula2.args;
+
+  if (args.length < 2) {
+    throw new Error('Requires more than one argument for calculation');
+  }
+
+  return round(args.map(function (a) {
+    return getValue(a, config.formData);
+  }).reduce(function (total, current, index) {
+    return index === 0 ? current : reduction(total, current);
+  }, 0), config);
+};
+
+var round = function round(number, config) {
+  var round = config.formula.round;
+  if (!round && round !== 0 || !number) return number;
+
+  if (round === 0) {
+    return parseInt(number);
+  } else {
+    var precisionScale = Math.pow(10, round);
+    return Math.round((number + Number.EPSILON) * precisionScale) / precisionScale;
+  }
+};
+
+var getValue = function getValue(arg, formData) {
+  var keys = Object.keys(arg);
+
+  if (keys.length === 1) {
+    var key = keys[0];
+    var val = arg[key];
+
+    switch (key) {
+      case 'field':
+        var fieldVal = fieldValue(val, formData);
+        return !fieldVal && fieldVal !== 0 ? NaN : parseFloat(fieldVal);
+
+      case 'value':
+        return parseFloat(val);
+
+      case 'formula':
+        return applyFormula(_objectSpread(_objectSpread({}, arg), {}, {
+          formData: formData
+        }));
+
+      default:
+        throw new Error('Only accept following as argument field: {field, value, or formula}');
+    }
+  } else {
+    throw new Error('Argument cannot have more than one reference');
+  }
+};
+
+var fieldValue = function fieldValue(field, data) {
+  return _copReactComponents.Utils.interpolateString('${' + field + '}', data);
+};
+
+var _default = applyFormula;
+exports.default = _default;

package/dist/utils/Data/applyFormula.test.js

@@ -0,0 +1,264 @@
+"use strict";
+
+var _applyFormula = _interopRequireDefault(require("./applyFormula"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Local imports
+describe('utils.Data.applyFormula', function () {
+  var error = jest.spyOn(console, 'error').mockImplementation(function () {});
+  afterAll(function () {
+    error.mockReset();
+  });
+  afterEach(function () {
+    error.mockClear();
+  });
+  it('should throw and handle exception for a null config', function () {
+    (0, _applyFormula.default)(null);
+    expect(error).toBeCalledWith("Missing 'formula' definition");
+  });
+  it("should throw and handle exception for config with missing 'formula'", function () {
+    (0, _applyFormula.default)({});
+    expect(error).toBeCalledWith("Missing 'formula' definition");
+  });
+  it("should throw and handle exception for config with 'formula' but missing 'name'", function () {
+    (0, _applyFormula.default)({
+      formula: {}
+    });
+    expect(error).toBeCalledWith("Calculation formula 'name' cannot be empty");
+  });
+  it("should throw and handle exception for config with 'formula' with unsupported operation 'name'", function () {
+    (0, _applyFormula.default)({
+      formula: {
+        name: "something"
+      }
+    });
+    expect(error).toBeCalledWith("Unsupported operation 'something'");
+  });
+  it("should throw and handle exception for 'formula' with wrong argument name", function () {
+    (0, _applyFormula.default)({
+      formula: {
+        name: 'plus',
+        args: [{
+          somthing: 1
+        }, {
+          somthing: 1
+        }]
+      }
+    });
+    expect(error).toBeCalledWith('Only accept following as argument field: {field, value, or formula}');
+  });
+  it("should throw and handle exception for 'formula' argument with more than one field", function () {
+    (0, _applyFormula.default)({
+      formula: {
+        name: 'plus',
+        args: [{
+          value: 1,
+          field: 'fieldA'
+        }, {
+          value: 1
+        }]
+      }
+    });
+    expect(error).toBeCalledWith('Argument cannot have more than one reference');
+  });
+  it("should throw and handle exception for 'formula' with single argument", function () {
+    (0, _applyFormula.default)({
+      formula: {
+        name: 'plus',
+        args: [{
+          value: 10
+        }]
+      }
+    });
+    expect(error).toBeCalledWith('Requires more than one argument for calculation');
+  });
+  var DATA = {
+    fieldA: '10',
+    fieldB: '20',
+    fieldC: 'abc',
+    fieldD: '0',
+    fieldE: '10'
+  };
+  [{
+    name: 'plus',
+    args: [{
+      field: 'fieldA'
+    }, {
+      field: 'fieldB'
+    }],
+    result: 30
+  }, {
+    name: 'minus',
+    args: [{
+      field: 'fieldB'
+    }, {
+      field: 'fieldA'
+    }],
+    result: 10
+  }, {
+    name: 'multiply',
+    args: [{
+      field: 'fieldA'
+    }, {
+      field: 'fieldB'
+    }],
+    result: 200
+  }, {
+    name: 'divide',
+    args: [{
+      field: 'fieldA'
+    }, {
+      field: 'fieldB'
+    }],
+    result: 0.5
+  }, {
+    name: 'divide',
+    args: [{
+      field: 'fieldA'
+    }, {
+      field: 'fieldD'
+    }],
+    result: Infinity
+  }, {
+    name: 'plus',
+    args: [{
+      field: 'fieldA'
+    }, {
+      field: 'fieldC'
+    }],
+    result: ''
+  }, {
+    name: 'multiply',
+    args: [{
+      field: 'fieldA'
+    }, {
+      field: 'fieldB'
+    }, {
+      field: 'fieldE'
+    }],
+    result: 2000
+  }].forEach(function (test) {
+    it("should calculate formula '".concat(test.name, "' correctly for field args to '").concat(test.result, "'"), function () {
+      var config = {
+        formData: DATA,
+        formula: {
+          name: test.name,
+          args: test.args
+        }
+      };
+      expect((0, _applyFormula.default)(config)).toEqual(test.result);
+    });
+  });
+  [{
+    fieldA: '1',
+    fieldB: '3',
+    round: 5,
+    result: 0.33333
+  }, {
+    fieldA: '2',
+    fieldB: '3',
+    round: 5,
+    result: 0.66667
+  }, {
+    fieldA: '1',
+    fieldB: '3',
+    round: 4,
+    result: 0.3333
+  }, {
+    fieldA: '2',
+    fieldB: '3',
+    round: 4,
+    result: 0.6667
+  }, {
+    fieldA: '1',
+    fieldB: '3',
+    round: 3,
+    result: 0.333
+  }, {
+    fieldA: '2',
+    fieldB: '3',
+    round: 3,
+    result: 0.667
+  }, {
+    fieldA: '1',
+    fieldB: '3',
+    round: 2,
+    result: 0.33
+  }, {
+    fieldA: '2',
+    fieldB: '3',
+    round: 2,
+    result: 0.67
+  }, {
+    fieldA: '1',
+    fieldB: '3',
+    round: 1,
+    result: 0.3
+  }, {
+    fieldA: '2',
+    fieldB: '3',
+    round: 1,
+    result: 0.7
+  }, {
+    fieldA: '1',
+    fieldB: '3',
+    round: 0,
+    result: 0
+  }, {
+    fieldA: '2',
+    fieldB: '3',
+    round: 0,
+    result: 0
+  }, {
+    fieldA: 'L',
+    fieldB: 'G3',
+    round: 1,
+    result: ''
+  }].forEach(function (test) {
+    it("should calculdate and round result to precision ".concat(test.round), function () {
+      var config = {
+        formData: {
+          fieldA: test.fieldA,
+          fieldB: test.fieldB
+        },
+        formula: {
+          name: 'divide',
+          round: test.round,
+          args: [{
+            field: 'fieldA'
+          }, {
+            field: 'fieldB'
+          }]
+        }
+      };
+      expect((0, _applyFormula.default)(config)).toEqual(test.result);
+    });
+  });
+  it("should calculate nested 'formula'", function () {
+    var config = {
+      formData: {
+        fieldA: '19',
+        fieldB: '66'
+      },
+      formula: {
+        name: 'multiply',
+        round: 2,
+        args: [{
+          formula: {
+            name: 'divide',
+            round: 4,
+            args: [{
+              field: 'fieldA'
+            }, {
+              field: 'fieldB'
+            }]
+          }
+        }, {
+          value: 100
+        }]
+      }
+    };
+    expect((0, _applyFormula.default)(config)).toEqual(28.79);
+  });
+});

package/dist/utils/Data/index.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _applyFormula = _interopRequireDefault(require("./applyFormula"));
+
 var _getAutocompleteSource = _interopRequireDefault(require("./getAutocompleteSource"));
 
 var _getDataPath = _interopRequireDefault(require("./getDataPath"));
@@ -25,6 +27,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 // Local imports
 var Data = {
+  applyFormula: _applyFormula.default,
   getAutocompleteSource: _getAutocompleteSource.default,
   getDataPath: _getDataPath.default,
   getOptions: _getOptions.default,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ukhomeoffice/cop-react-form-renderer",
-  "version": "3.8.0",
+  "version": "3.10.0",
   "private": false,
   "scripts": {
     "clean": "rimraf dist",
@@ -16,7 +16,7 @@
     "post-compile": "rimraf dist/*.test.* dist/**/*.test.* dist/**/*.stories.* dist/docs dist/assets"
   },
   "dependencies": {
-    "@ukhomeoffice/cop-react-components": "1.9.5",
+    "@ukhomeoffice/cop-react-components": "1.10.0",
     "axios": "^0.23.0",
     "dayjs": "^1.11.0",
     "govuk-frontend": "^3.13.0",