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

package/dist/utils/Data/applyFormula.js

@@ -5,14 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _copReactComponents = require("@ukhomeoffice/cop-react-components");
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : 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; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 var applyFormula = function applyFormula(config) {
   try {
     var result = simplify(config);
     return !result && result !== 0 ? '' : result;
   } catch (err) {
+    // eslint-disable-next-line no-console
     console.error(err.message);
   }
   return '';
@@ -57,14 +61,13 @@ var reduceNumber = function reduceNumber(config, reduction) {
   }, 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 roundNumber = config.formula.round;
+  if (!roundNumber && roundNumber !== 0 || !number) return number;
+  if (roundNumber === 0) {
+    return parseInt(number, 10);
   }
+  var precisionScale = Math.pow(10, roundNumber);
+  return Math.round((number + Number.EPSILON) * precisionScale) / precisionScale;
 };
 var getValue = function getValue(arg, formData) {
   var keys = Object.keys(arg);
@@ -73,8 +76,11 @@ var getValue = function getValue(arg, formData) {
     var val = arg[key];
     switch (key) {
       case 'field':
-        var fieldVal = fieldValue(val, formData);
-        return !fieldVal && fieldVal !== 0 ? NaN : parseFloat(fieldVal);
+        {
+          var fieldVal = fieldValue(val, formData);
+          return !fieldVal && fieldVal !== 0 ? NaN : parseFloat(fieldVal);
+        }
+        ;
       case 'value':
         return parseFloat(val);
       case 'formula':
@@ -89,7 +95,10 @@ var getValue = function getValue(arg, formData) {
   }
 };
 var fieldValue = function fieldValue(field, data) {
-  return _copReactComponents.Utils.interpolateString('${' + field + '}', data);
+  return (
+    // eslint-disable-next-line prefer-template
+    _copReactComponents.Utils.interpolateString('${' + field + '}', data)
+  );
 };
 var _default = applyFormula;
 exports.default = _default;

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

@@ -0,0 +1,263 @@
+"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/getAutocompleteSource.js

@@ -4,8 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _copReactComponents = require("@ukhomeoffice/cop-react-components");
 var _getOptions = _interopRequireDefault(require("./getOptions"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Global Imports
+
 // Local imports
 
 var getAutocompleteSource = function getAutocompleteSource(config) {
@@ -13,11 +16,12 @@ var getAutocompleteSource = function getAutocompleteSource(config) {
   (0, _getOptions.default)(config, function (val) {
     options = val;
   });
+  var labelMaker = config !== null && config !== void 0 && config.item ? _copReactComponents.Utils.itemLabel(config.item) : null;
   return function (query, populateResults) {
     var lcQuery = query ? query.toLowerCase() : '';
     populateResults(options.filter(function (opt) {
-      var lcLabel = opt.label ? opt.label.toLowerCase() : '';
-      return lcLabel.includes(lcQuery);
+      var label = labelMaker ? labelMaker(opt) : opt.label || '';
+      return label.toLowerCase().includes(lcQuery);
     }));
   };
 };

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

@@ -0,0 +1,352 @@
+"use strict";
+
+var _getAutocompleteSource = _interopRequireDefault(require("./getAutocompleteSource"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Local imports
+
+describe('utils', function () {
+  describe('Data', function () {
+    describe('getAutocompleteSource', function () {
+      it('should handle a null config', function () {
+        var SOURCE = (0, _getAutocompleteSource.default)(null);
+        expect(typeof SOURCE === 'function').toBeTruthy();
+        SOURCE('query', function (results) {
+          expect(Array.isArray(results)).toBeTruthy();
+          expect(results.length).toEqual(0);
+        });
+      });
+      describe('without custom item labels', function () {
+        it('should get any specified options from the config', function () {
+          var CONFIG = {
+            data: {
+              options: [{
+                value: 'a',
+                label: 'Alpha'
+              }, {
+                value: 'b',
+                label: 'Bravo'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          expect(typeof SOURCE === 'function').toBeTruthy();
+          SOURCE('a', function (results) {
+            expect(results.length).toEqual(2);
+            expect(results).toEqual([{
+              value: 'a',
+              label: 'Alpha'
+            }, {
+              value: 'b',
+              label: 'Bravo'
+            }]);
+          });
+          SOURCE('al', function (results) {
+            expect(results.length).toEqual(1);
+            expect(results).toEqual([{
+              value: 'a',
+              label: 'Alpha'
+            }]);
+          });
+        });
+        it('should handle an empty query', function () {
+          var CONFIG = {
+            data: {
+              options: [{
+                value: 'a',
+                label: 'Alpha'
+              }, {
+                value: 'b',
+                label: 'Bravo'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          SOURCE('', function (results) {
+            expect(results.length).toEqual(2);
+            expect(results).toEqual([{
+              value: 'a',
+              label: 'Alpha'
+            }, {
+              value: 'b',
+              label: 'Bravo'
+            }]);
+          });
+        });
+        it('should handle an undefined query', function () {
+          var CONFIG = {
+            data: {
+              options: [{
+                value: 'a',
+                label: 'Alpha'
+              }, {
+                value: 'b',
+                label: 'Bravo'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          SOURCE(undefined, function (results) {
+            expect(results.length).toEqual(2);
+            expect(results).toEqual([{
+              value: 'a',
+              label: 'Alpha'
+            }, {
+              value: 'b',
+              label: 'Bravo'
+            }]);
+          });
+        });
+        it('should handle a null query', function () {
+          var CONFIG = {
+            data: {
+              options: [{
+                value: 'a',
+                label: 'Alpha'
+              }, {
+                value: 'b',
+                label: 'Bravo'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          SOURCE(null, function (results) {
+            expect(results.length).toEqual(2);
+            expect(results).toEqual([{
+              value: 'a',
+              label: 'Alpha'
+            }, {
+              value: 'b',
+              label: 'Bravo'
+            }]);
+          });
+        });
+        it('should handle a missing label on an option', function () {
+          var CONFIG = {
+            data: {
+              options: [{
+                value: 'a',
+                label: 'Alpha'
+              }, {
+                value: 'b'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          expect(typeof SOURCE === 'function').toBeTruthy();
+          SOURCE('a', function (results) {
+            expect(results.length).toEqual(1);
+            expect(results).toEqual([{
+              value: 'a',
+              label: 'Alpha'
+            }]);
+          });
+        });
+      });
+      describe('with custom item labels', function () {
+        it('should get any specified options from the config', function () {
+          var CONFIG = {
+            item: {
+              value: 'currencyCode',
+              label: 'currencyCode',
+              // eslint-disable-next-line no-template-curly-in-string
+              format: '${currencyName} (${currencyCode})'
+            },
+            data: {
+              options: [{
+                currencyName: 'Great British Pounds',
+                currencyCode: 'GBP',
+                value: 'GBP',
+                label: 'GBP'
+              }, {
+                currencyName: 'United States Dollars',
+                currencyCode: 'USD',
+                value: 'USD',
+                label: 'USD'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          expect(typeof SOURCE === 'function').toBeTruthy();
+          SOURCE('GB', function (results) {
+            expect(results.length).toEqual(1);
+            expect(results).toEqual([{
+              currencyName: 'Great British Pounds',
+              currencyCode: 'GBP',
+              value: 'GBP',
+              label: 'GBP'
+            }]);
+          });
+          SOURCE(' (', function (results) {
+            expect(results.length).toEqual(2);
+            expect(results).toEqual([{
+              currencyName: 'Great British Pounds',
+              currencyCode: 'GBP',
+              value: 'GBP',
+              label: 'GBP'
+            }, {
+              currencyName: 'United States Dollars',
+              currencyCode: 'USD',
+              value: 'USD',
+              label: 'USD'
+            }]);
+          });
+        });
+        it('should handle an empty query', function () {
+          var CONFIG = {
+            item: {
+              value: 'currencyCode',
+              label: 'currencyCode',
+              // eslint-disable-next-line no-template-curly-in-string
+              format: '${currencyName} (${currencyCode})'
+            },
+            data: {
+              options: [{
+                currencyName: 'Great British Pounds',
+                currencyCode: 'GBP',
+                value: 'GBP',
+                label: 'GBP'
+              }, {
+                currencyName: 'United States Dollars',
+                currencyCode: 'USD',
+                value: 'USD',
+                label: 'USD'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          SOURCE('', function (results) {
+            expect(results.length).toEqual(2);
+            expect(results).toEqual([{
+              currencyName: 'Great British Pounds',
+              currencyCode: 'GBP',
+              value: 'GBP',
+              label: 'GBP'
+            }, {
+              currencyName: 'United States Dollars',
+              currencyCode: 'USD',
+              value: 'USD',
+              label: 'USD'
+            }]);
+          });
+        });
+        it('should handle an undefined query', function () {
+          var CONFIG = {
+            item: {
+              value: 'currencyCode',
+              label: 'currencyCode',
+              // eslint-disable-next-line no-template-curly-in-string
+              format: '${currencyName} (${currencyCode})'
+            },
+            data: {
+              options: [{
+                currencyName: 'Great British Pounds',
+                currencyCode: 'GBP',
+                value: 'GBP',
+                label: 'GBP'
+              }, {
+                currencyName: 'United States Dollars',
+                currencyCode: 'USD',
+                value: 'USD',
+                label: 'USD'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          SOURCE(undefined, function (results) {
+            expect(results.length).toEqual(2);
+            expect(results).toEqual([{
+              currencyName: 'Great British Pounds',
+              currencyCode: 'GBP',
+              value: 'GBP',
+              label: 'GBP'
+            }, {
+              currencyName: 'United States Dollars',
+              currencyCode: 'USD',
+              value: 'USD',
+              label: 'USD'
+            }]);
+          });
+        });
+        it('should handle a null query', function () {
+          var CONFIG = {
+            item: {
+              value: 'currencyCode',
+              label: 'currencyCode',
+              // eslint-disable-next-line no-template-curly-in-string
+              format: '${currencyName} (${currencyCode})'
+            },
+            data: {
+              options: [{
+                currencyName: 'Great British Pounds',
+                currencyCode: 'GBP',
+                value: 'GBP',
+                label: 'GBP'
+              }, {
+                currencyName: 'United States Dollars',
+                currencyCode: 'USD',
+                value: 'USD',
+                label: 'USD'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          SOURCE(null, function (results) {
+            expect(results.length).toEqual(2);
+            expect(results).toEqual([{
+              currencyName: 'Great British Pounds',
+              currencyCode: 'GBP',
+              value: 'GBP',
+              label: 'GBP'
+            }, {
+              currencyName: 'United States Dollars',
+              currencyCode: 'USD',
+              value: 'USD',
+              label: 'USD'
+            }]);
+          });
+        });
+        it('should handle a missing label on an option', function () {
+          var CONFIG = {
+            item: {
+              value: 'currencyCode',
+              label: 'currencyCode',
+              // eslint-disable-next-line no-template-curly-in-string
+              format: '${currencyName} (${currencyCode})'
+            },
+            data: {
+              options: [{
+                currencyName: 'Great British Pounds',
+                currencyCode: 'GBP',
+                value: 'GBP',
+                label: 'GBP'
+              }, {
+                currencyName: 'United States Dollars',
+                currencyCode: 'USD',
+                value: 'USD'
+              }]
+            }
+          };
+          var SOURCE = (0, _getAutocompleteSource.default)(CONFIG);
+          expect(typeof SOURCE === 'function').toBeTruthy();
+          SOURCE('a', function (results) {
+            // We expect 2 results here instead of 1 because defining a custom
+            // format for item labels means the label is constructed upon processing
+            // a query - we're not relying on the 'label' field of the option.
+            expect(results.length).toEqual(2);
+            expect(results).toEqual([{
+              currencyName: 'Great British Pounds',
+              currencyCode: 'GBP',
+              value: 'GBP',
+              label: 'GBP'
+            }, {
+              currencyName: 'United States Dollars',
+              currencyCode: 'USD',
+              value: 'USD',
+              label: ''
+            }]);
+          });
+        });
+      });
+    });
+  });
+});