@ukhomeoffice/cop-react-form-renderer 3.7.0-alpha → 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/dist/utils/Data/setupFormData.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
 var _getSourceData = _interopRequireDefault(require("./getSourceData"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -15,6 +17,56 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 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 setDefaultDateValue = function setDefaultDateValue(date, data) {
+  if (date.defaultValue === 'today') {
+    data[date.fieldId] = (0, _dayjs.default)().format('DD-MM-YYYY');
+  } else {
+    data[date.fieldId] = date.defaultValue;
+  }
+};
+/** 
+ * This currently will not work for collections or containers.
+ * If support is required it will need to be added.
+ */
+
+
+var setupDefaultValue = function setupDefaultValue(component, data) {
+  if (component.defaultValue && !data[component.fieldId]) {
+    switch (component.type) {
+      case 'date':
+        setDefaultDateValue(component, data);
+        break;
+
+      default:
+        data[component.fieldId] = component.defaultValue;
+    }
+  }
+
+  if (component.defaultValue) {
+    // Some components will throw warnings when having 
+    // both a 'value' and 'defaultValue' prop set. 
+    // defaultValue is safe to delete once we've tried
+    // to use it.
+    delete component.defaultValue;
+  }
+};
+
+var setupDefaultValuesForComponents = function setupDefaultValuesForComponents(components, data) {
+  components.forEach(function (component) {
+    return setupDefaultValue(component, data);
+  });
+};
+
+var setupPageDefaultValues = function setupPageDefaultValues(pages, data) {
+  pages.forEach(function (page) {
+    page.components.filter(function (c) {
+      return !c.use;
+    }).forEach(function (component) {
+      return setupDefaultValue(component, data);
+    });
+  });
+};
+
 var setupComponentSourceData = function setupComponentSourceData(component, data) {
   if (component.source) {
     data[component.fieldId] = (0, _getSourceData.default)(data, component.source.field);
@@ -37,8 +89,11 @@ var setupPageSourceData = function setupPageSourceData(pages, data) {
   });
 };
 /**
- * This populates an object with data from source fields.
- * Note that this doesn't currently support sequenced dependencies:
+ * This populates an object with data either from a specified default
+ * value or from a source field. If both are specified, data from a
+ * source field will take priority.
+ * Note that in the case of source fields, this doesn't currently 
+ * support sequenced dependencies:
  *    0: fieldA: source.field = fieldB
  *    1: fieldB: source.field = fieldC
  *    2: fieldC: 'value'
@@ -54,6 +109,8 @@ var setupPageSourceData = function setupPageSourceData(pages, data) {
 var setupFormData = function setupFormData(pages, components, baseData) {
   var data = _objectSpread({}, baseData);
 
+  setupDefaultValuesForComponents(components, data);
+  setupPageDefaultValues(pages, data);
   setupSourceDataForComponents(components, data);
   setupPageSourceData(pages, data);
   return data;

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

@@ -211,6 +211,66 @@ describe('utils', function () {
           delegateEmails: _userProfileData.default.userDetails.delegateEmails
         }));
       });
+      it('should handle a default value field', function () {
+        var PAGES = [];
+        var COMPONENTS = [{
+          fieldId: 'testField',
+          type: 'text',
+          defaultValue: 'VALUE'
+        }];
+        var DATA = {};
+        var RESULT = (0, _setupFormData.default)(PAGES, COMPONENTS, DATA);
+        expect(RESULT).toEqual({
+          testField: 'VALUE'
+        });
+      });
+      it('should ignore a default value when a value already exists in data', function () {
+        var PAGES = [];
+        var COMPONENTS = [{
+          fieldId: 'testField',
+          type: 'text',
+          defaultValue: 'VALUE'
+        }];
+        var DATA = {
+          testField: 'EXISTING_VALUE'
+        };
+        var RESULT = (0, _setupFormData.default)(PAGES, COMPONENTS, DATA);
+        expect(RESULT).toEqual({
+          testField: 'EXISTING_VALUE'
+        });
+      });
+      it('should handle default values within pages', function () {
+        var PAGES = [{
+          components: [{
+            fieldId: 'pageField',
+            type: 'text',
+            defaultValue: 'VALUE'
+          }]
+        }];
+        var COMPONENTS = [];
+        var DATA = {};
+        var RESULT = (0, _setupFormData.default)(PAGES, COMPONENTS, DATA);
+        expect(RESULT).toEqual({
+          pageField: 'VALUE'
+        });
+      });
+      it('should ignore default values within pages when a value already exists in data', function () {
+        var PAGES = [{
+          components: [{
+            fieldId: 'pageField',
+            type: 'text',
+            defaultValue: 'VALUE'
+          }]
+        }];
+        var COMPONENTS = [];
+        var DATA = {
+          pageField: 'EXISTING_VALUE'
+        };
+        var RESULT = (0, _setupFormData.default)(PAGES, COMPONENTS, DATA);
+        expect(RESULT).toEqual({
+          pageField: 'EXISTING_VALUE'
+        });
+      });
     });
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ukhomeoffice/cop-react-form-renderer",
-  "version": "3.7.0-alpha",
+  "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",