@ukhomeoffice/cop-react-form-renderer 0.1.0-beta

package/dist/utils/Validate/validateComponent.test.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _models = require("../../models");
+
+var _validateComponent = _interopRequireDefault(require("./validateComponent"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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', function () {
+  describe('Validate', function () {
+    describe('component', function () {
+      var setup = function setup(id, type, label, required) {
+        return {
+          id: id,
+          fieldId: id,
+          type: type,
+          label: label,
+          required: required
+        };
+      };
+
+      it('should return no error when the component is null', function () {
+        expect((0, _validateComponent.default)(null, {})).toBeUndefined();
+      });
+      describe('when there is no form data', function () {
+        it('should return no error when the component is not required and not an email type', function () {
+          var ID = 'field';
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.TEXT, LABEL, false);
+          expect((0, _validateComponent.default)(COMPONENT, null)).toBeUndefined();
+        });
+        it('should return a required error when the component is required and not an email type', function () {
+          var ID = 'field';
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.TEXT, LABEL, true);
+          expect((0, _validateComponent.default)(COMPONENT, null)).toEqual({
+            id: ID,
+            error: "".concat(LABEL, " is required")
+          });
+        });
+        it('should return a required error when the component is required and of type email', function () {
+          var ID = 'field';
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.EMAIL, LABEL, true);
+          expect((0, _validateComponent.default)(COMPONENT, null)).toEqual({
+            id: ID,
+            error: "".concat(LABEL, " is required")
+          });
+        });
+        it('should return no error when the component is of type email but not required', function () {
+          var ID = 'field';
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.EMAIL, LABEL, false);
+          expect((0, _validateComponent.default)(COMPONENT, null)).toBeUndefined();
+        });
+      });
+      describe('when the value is fully valid', function () {
+        var ID = 'field';
+
+        var DATA = _defineProperty({}, ID, 'alpha.bravo@digital.homeoffice.gov.uk');
+
+        it('should return no error when the component is not required and not an email type', function () {
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.TEXT, LABEL, false);
+          expect((0, _validateComponent.default)(COMPONENT, DATA)).toBeUndefined();
+        });
+        it('should return no error when the component is required and not an email type', function () {
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.TEXT, LABEL, true);
+          expect((0, _validateComponent.default)(COMPONENT, DATA)).toBeUndefined();
+        });
+        it('should return no error when the component is required and of type email', function () {
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.EMAIL, LABEL, true);
+          expect((0, _validateComponent.default)(COMPONENT, DATA)).toBeUndefined();
+        });
+        it('should return no error when the component is of type email but not required', function () {
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.EMAIL, LABEL, false);
+          expect((0, _validateComponent.default)(COMPONENT, DATA)).toBeUndefined();
+        });
+      });
+      describe('when the value is an invalid email', function () {
+        var ID = 'field';
+
+        var DATA = _defineProperty({}, ID, 'alpha.bravo@hotmail.com');
+
+        it('should return no error when the component is not required and not an email type', function () {
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.TEXT, LABEL, false);
+          expect((0, _validateComponent.default)(COMPONENT, DATA)).toBeUndefined();
+        });
+        it('should return no error when the component is required and not an email type', function () {
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.TEXT, LABEL, true);
+          expect((0, _validateComponent.default)(COMPONENT, DATA)).toBeUndefined();
+        });
+        it('should return no error when the component is required and of type email', function () {
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.EMAIL, LABEL, true);
+          expect((0, _validateComponent.default)(COMPONENT, DATA)).toEqual({
+            id: ID,
+            error: "Enter ".concat(LABEL.toLowerCase(), " in the correct format, like jane.doe@homeoffice.gov.uk")
+          });
+        });
+        it('should return no error when the component is of type email but not required', function () {
+          var LABEL = 'Field';
+          var COMPONENT = setup(ID, _models.ComponentTypes.EMAIL, LABEL, false);
+          expect((0, _validateComponent.default)(COMPONENT, DATA)).toEqual({
+            id: ID,
+            error: "Enter ".concat(LABEL.toLowerCase(), " in the correct format, like jane.doe@homeoffice.gov.uk")
+          });
+        });
+      });
+    });
+  });
+});

package/dist/utils/Validate/validateEmail.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// eslint-disable-next-line no-control-regex
+// const EMAIL_REGEX = /(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/i;
+var HODS_EMAIL_REGEX = /^[a-z0-9._-]+@(digital\.)?homeoffice.gov.uk$/i;
+/**
+ * Validates an email address, ensuring it is in the correct domain and
+ * complies with the Home Office email address standards.
+ * 
+ * Note that an empty string is not considered invalid. You should use
+ * validateRequired (Validate.required) for that sort of validation.
+ * @param {*} value The value to validate.
+ * @param {string} label The label to use in any error message.
+ * @returns An error if the email address is invalid.
+ */
+
+var validateEmail = function validateEmail(value) {
+  var label = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+  if (!!value) {
+    if (typeof value === 'string') {
+      if (HODS_EMAIL_REGEX.test(value)) {
+        return undefined;
+      }
+    }
+
+    var name = label ? label.toLowerCase() : 'email address';
+    return "Enter ".concat(name, " in the correct format, like jane.doe@homeoffice.gov.uk");
+  }
+
+  return undefined;
+};
+
+var _default = validateEmail;
+exports.default = _default;

package/dist/utils/Validate/validateEmail.test.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _validateEmail = _interopRequireDefault(require("./validateEmail"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Local imports
+describe('utils', function () {
+  describe('Validate', function () {
+    describe('email', function () {
+      var LABEL = 'Component';
+      var ERROR = "Enter ".concat(LABEL.toLowerCase(), " in the correct format, like jane.doe@homeoffice.gov.uk"); // Valid values
+
+      it('should return no error when the value is a valid .gov.uk address', function () {
+        expect((0, _validateEmail.default)('alpha@homeoffice.gov.uk', LABEL)).toBeUndefined();
+      });
+      it('should return no error when the value is a capitalised digital.homeoffice.gov.uk address', function () {
+        expect((0, _validateEmail.default)('ALPHA.BRAVO@DIGITAL.HOMEOFFICE.GOV.UK', LABEL)).toBeUndefined();
+      });
+      it('should return no error when the value is an empty string', function () {
+        expect((0, _validateEmail.default)('', LABEL)).toBeUndefined();
+      }); // Invalid values
+
+      it('should return an error when the value is an empty object', function () {
+        expect((0, _validateEmail.default)({}, LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the value is an array', function () {
+        expect((0, _validateEmail.default)(['bob'], LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the value is numeric', function () {
+        expect((0, _validateEmail.default)(24, LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the value is in the wrong domain', function () {
+        expect((0, _validateEmail.default)('alpha@domain.com', LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the domain contains spaces', function () {
+        expect((0, _validateEmail.default)('alpha.bravo@digital homeoffice.gov.uk', LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the value has no TLD', function () {
+        expect((0, _validateEmail.default)('alpha.bravo@homeoffice', LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when there is no name', function () {
+        expect((0, _validateEmail.default)('@homeoffice.gov.uk', LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when there is no @ symbol', function () {
+        expect((0, _validateEmail.default)('alpha.bravo.homeoffice.gov.uk', LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the name contains spaces', function () {
+        expect((0, _validateEmail.default)('alpha bravo@digital.homeoffice.gov.uk', LABEL)).toEqual(ERROR);
+      });
+      it('should use a default label when none is specified', function () {
+        var DEFAULT_ERROR = 'Enter email address in the correct format, like jane.doe@homeoffice.gov.uk';
+        expect((0, _validateEmail.default)(['bob'], undefined)).toEqual(DEFAULT_ERROR);
+      });
+    });
+  });
+});

package/dist/utils/Validate/validatePage.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validateComponent = _interopRequireDefault(require("./validateComponent"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Local imports
+
+/**
+ * Validate all of the components on a page.
+ * @param {Array} components The components to validate.
+ * @param {object} formData The data to use that holds this components' values.
+ * @returns An array containing all of the errors.
+ */
+var validatePage = function validatePage(components, formData) {
+  var errors = [];
+
+  if (Array.isArray(components)) {
+    components.forEach(function (component) {
+      errors.push((0, _validateComponent.default)(component, formData));
+    });
+  }
+
+  return errors.filter(function (e) {
+    return !!e;
+  });
+};
+
+var _default = validatePage;
+exports.default = _default;

package/dist/utils/Validate/validatePage.test.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _models = require("../../models");
+
+var _validatePage = _interopRequireDefault(require("./validatePage"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Local imports
+describe('utils', function () {
+  describe('Validate', function () {
+    describe('page', function () {
+      var setup = function setup(id, type, label, required) {
+        return {
+          id: id,
+          fieldId: id,
+          type: type,
+          label: label,
+          required: required
+        };
+      };
+
+      it('should return no error when the components array is null', function () {
+        expect((0, _validatePage.default)(null, {}).length).toEqual(0);
+      });
+      it('should return no error when the components array is empty', function () {
+        expect((0, _validatePage.default)([], {}).length).toEqual(0);
+      });
+      describe('when there is no form data', function () {
+        it('should return a single error when no components are required', function () {
+          var COMPONENTS = [setup('a', _models.ComponentTypes.TEXT, 'Alpha', false), setup('b', _models.ComponentTypes.TEXT, 'Bravo', false)];
+          expect((0, _validatePage.default)(COMPONENTS, null).length).toEqual(0);
+        });
+        it('should return an error for each required component', function () {
+          var COMPONENTS = [setup('a', _models.ComponentTypes.TEXT, 'Alpha', true), setup('b', _models.ComponentTypes.TEXT, 'Bravo', true), setup('c', _models.ComponentTypes.TEXT, 'Charlie', false), // The only unrequired one
+          setup('d', _models.ComponentTypes.TEXT, 'Delta', true), setup('e', _models.ComponentTypes.TEXT, 'Echo', true)];
+          var RESULT = (0, _validatePage.default)(COMPONENTS, null);
+          expect(RESULT.length).toEqual(4);
+          expect(RESULT[0]).toEqual({
+            id: 'a',
+            error: 'Alpha is required'
+          });
+          expect(RESULT[1]).toEqual({
+            id: 'b',
+            error: 'Bravo is required'
+          });
+          expect(RESULT[2]).toEqual({
+            id: 'd',
+            error: 'Delta is required'
+          });
+          expect(RESULT[3]).toEqual({
+            id: 'e',
+            error: 'Echo is required'
+          });
+        });
+      });
+      describe('when the form data is fully valid', function () {
+        var DATA = {
+          alpha: 'alpha.smith@digital.homeoffice.gov.uk',
+          bravo: 'bravo.jones@digital.homeoffice.gov.uk'
+        };
+        it('should return no errors when none of the components are required or email types', function () {
+          var COMPONENTS = [setup('alpha', _models.ComponentTypes.TEXT, 'Alpha', false), setup('bravo', _models.ComponentTypes.TEXT, 'Bravo', false)];
+          expect((0, _validatePage.default)(COMPONENTS, DATA).length).toEqual(0);
+        });
+        it('should return no errors when all of the components are required but not email types', function () {
+          var COMPONENTS = [setup('alpha', _models.ComponentTypes.TEXT, 'Alpha', true), setup('bravo', _models.ComponentTypes.TEXT, 'Bravo', true)];
+          expect((0, _validatePage.default)(COMPONENTS, DATA).length).toEqual(0);
+        });
+        it('should return no errors when none of the components are required but are all email types', function () {
+          var COMPONENTS = [setup('alpha', _models.ComponentTypes.EMAIL, 'Alpha', false), setup('bravo', _models.ComponentTypes.EMAIL, 'Bravo', false)];
+          expect((0, _validatePage.default)(COMPONENTS, DATA).length).toEqual(0);
+        });
+        it('should return no errors when all of the components are required and email types', function () {
+          var COMPONENTS = [setup('alpha', _models.ComponentTypes.EMAIL, 'Alpha', true), setup('bravo', _models.ComponentTypes.EMAIL, 'Bravo', true)];
+          expect((0, _validatePage.default)(COMPONENTS, DATA).length).toEqual(0);
+        });
+      });
+      describe('when the form data has one field missing and includes an invalid email', function () {
+        var DATA = {
+          alpha: 'alpha.smith@digital.homeoffice.gov.uk',
+          bravo: 'bravo.jones@hotmail.com'
+        };
+        it('should return no errors when none of the components are required or email types', function () {
+          var COMPONENTS = [setup('alpha', _models.ComponentTypes.TEXT, 'Alpha', false), setup('bravo', _models.ComponentTypes.TEXT, 'Bravo', false), setup('charlie', _models.ComponentTypes.TEXT, 'Charlie', false)];
+          expect((0, _validatePage.default)(COMPONENTS, DATA).length).toEqual(0);
+        });
+        it('should return an error for the missing field when all are required but not email types', function () {
+          var COMPONENTS = [setup('alpha', _models.ComponentTypes.TEXT, 'Alpha', true), setup('bravo', _models.ComponentTypes.TEXT, 'Bravo', true), setup('charlie', _models.ComponentTypes.TEXT, 'Charlie', true)];
+          var RESULT = (0, _validatePage.default)(COMPONENTS, DATA);
+          expect(RESULT.length).toEqual(1);
+          expect(RESULT[0]).toEqual({
+            id: 'charlie',
+            error: 'Charlie is required'
+          });
+        });
+        it('should return an error for the invalid email field when none are required but all email types', function () {
+          var COMPONENTS = [setup('alpha', _models.ComponentTypes.EMAIL, 'Alpha', false), setup('bravo', _models.ComponentTypes.EMAIL, 'Bravo', false), setup('charlie', _models.ComponentTypes.EMAIL, 'Charlie', false)];
+          var RESULT = (0, _validatePage.default)(COMPONENTS, DATA);
+          expect(RESULT.length).toEqual(1);
+          expect(RESULT[0]).toEqual({
+            id: 'bravo',
+            error: 'Enter bravo in the correct format, like jane.doe@homeoffice.gov.uk'
+          });
+        });
+        it('should return an error for both invalid fields when all are required and email types', function () {
+          var COMPONENTS = [setup('alpha', _models.ComponentTypes.EMAIL, 'Alpha', true), setup('bravo', _models.ComponentTypes.EMAIL, 'Bravo', true), setup('charlie', _models.ComponentTypes.EMAIL, 'Charlie', true)];
+          var RESULT = (0, _validatePage.default)(COMPONENTS, DATA);
+          expect(RESULT.length).toEqual(2);
+          expect(RESULT[0]).toEqual({
+            id: 'bravo',
+            error: 'Enter bravo in the correct format, like jane.doe@homeoffice.gov.uk'
+          });
+          expect(RESULT[1]).toEqual({
+            id: 'charlie',
+            error: 'Charlie is required'
+          });
+        });
+      });
+    });
+  });
+});

package/dist/utils/Validate/validateRequired.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ * Validates that a value is not nullish, which includes ensuring
+ * a string isn't just whitespace, an array is not empty, etc.
+ * @param {any} value The value to validate.
+ * @param {string} label The label to use in any error message.
+ * @returns An error if the value is nullish.
+ */
+var validateRequired = function validateRequired(value) {
+  var label = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var hasValue = false;
+
+  if (!!value || value === false || value === 0) {
+    hasValue = true;
+
+    if (typeof value === 'string') {
+      hasValue = value.trim().length > 0;
+    } else if (Array.isArray(value)) {
+      hasValue = value.length > 0;
+    }
+  }
+
+  if (!hasValue) {
+    var name = label ? label : 'Field';
+    return "".concat(name, " is required");
+  }
+
+  return undefined;
+};
+
+var _default = validateRequired;
+exports.default = _default;

package/dist/utils/Validate/validateRequired.test.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _validateRequired = _interopRequireDefault(require("./validateRequired"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Local imports
+describe('utils', function () {
+  describe('Validate', function () {
+    describe('required', function () {
+      var LABEL = 'Component';
+      var ERROR = "".concat(LABEL, " is required"); // Valid values
+
+      it('should return no error when the value is set', function () {
+        expect((0, _validateRequired.default)('value', LABEL)).toBeUndefined();
+      });
+      it('should return no error when the value is an empty object', function () {
+        expect((0, _validateRequired.default)({}, LABEL)).toBeUndefined();
+      });
+      it('should return no error when the value is a non-empty array', function () {
+        expect((0, _validateRequired.default)(['bob'], LABEL)).toBeUndefined();
+      });
+      it('should return no error when the value is a boolean false', function () {
+        expect((0, _validateRequired.default)(false, LABEL)).toBeUndefined();
+      });
+      it('should return no error when the value is the number zero', function () {
+        expect((0, _validateRequired.default)(0, LABEL)).toBeUndefined();
+      }); // Invalid values
+
+      it('should return an error when the value is undefined', function () {
+        expect((0, _validateRequired.default)(undefined, LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the value is null', function () {
+        expect((0, _validateRequired.default)(null, LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the value is an empty string', function () {
+        expect((0, _validateRequired.default)('', LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the value is a string containing just spaces', function () {
+        expect((0, _validateRequired.default)('     ', LABEL)).toEqual(ERROR);
+      });
+      it('should return an error when the value is an empty array', function () {
+        expect((0, _validateRequired.default)([], LABEL)).toEqual(ERROR);
+      });
+      it('should use a default label when none is specified', function () {
+        expect((0, _validateRequired.default)(undefined, undefined)).toEqual('Field is required');
+      });
+    });
+  });
+});

package/dist/utils/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _copReactComponents = require("@ukhomeoffice/cop-react-components");
+
+var _CheckYourAnswers = _interopRequireDefault(require("./CheckYourAnswers"));
+
+var _Component = _interopRequireDefault(require("./Component"));
+
+var _Data = _interopRequireDefault(require("./Data"));
+
+var _FormPage = _interopRequireDefault(require("./FormPage"));
+
+var _Hub = _interopRequireDefault(require("./Hub"));
+
+var _meetsCondition = _interopRequireDefault(require("./meetsCondition"));
+
+var _Validate = _interopRequireDefault(require("./Validate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 Utils = _objectSpread({
+  CheckYourAnswers: _CheckYourAnswers.default,
+  Component: _Component.default,
+  Data: _Data.default,
+  FormPage: _FormPage.default,
+  Hub: _Hub.default,
+  meetsCondition: _meetsCondition.default,
+  Validate: _Validate.default
+}, _copReactComponents.Utils);
+
+var _default = Utils;
+exports.default = _default;

package/dist/utils/meetsCondition.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var getComparisonValue = function getComparisonValue(condition) {
+  if (['in', 'nin'].includes(condition.op)) {
+    return condition.values;
+  }
+
+  return condition.value;
+};
+/**
+ * Looks at a condition object to see if the supplied value meets it.
+ * The condition object contains an `op` property, along with a comparator
+ * `value` (or `values`).
+ * 
+ * The evaluation is strict - i.e., it matches the value AND the type.
+ * 
+ * @param {object} condition The condition object.
+ * @param {*} value The value to test against the condition.
+ * 
+ * @returns A boolean indicating whether the value meets the condition.
+ */
+
+
+var meetsCondition = function meetsCondition(condition, value) {
+  if (condition && _typeof(condition) === 'object') {
+    var compare = getComparisonValue(condition);
+
+    switch (condition.op) {
+      case '=':
+      case 'eq':
+        {
+          return compare === value;
+        }
+
+      case '!=':
+      case '<>':
+      case 'ne':
+      case 'neq':
+        {
+          return compare !== value;
+        }
+
+      case 'in':
+        {
+          if (Array.isArray(compare)) {
+            return compare.includes(value);
+          } // If it's not an array, nothing can be IN it, so it must fail the condition.
+
+
+          return false;
+        }
+
+      case 'nin':
+        {
+          if (Array.isArray(compare)) {
+            return compare.includes(value) === false;
+          } // If it's not an array, nothing can be IN it, so it must meet the condition.
+
+
+          return true;
+        }
+
+      default:
+        return false;
+    }
+  }
+
+  return true;
+};
+
+var _default = meetsCondition;
+exports.default = _default;