@ukhomeoffice/cop-react-form-renderer 2.2.0 → 2.6.1-alpha

package/dist/utils/Hub/getFormHub.test.js

@@ -63,11 +63,11 @@ describe('utils', function () {
         it("should return an appropriate page when the format is not \"".concat(_models.HubFormats.CYA, "\" and hub contains components"), function () {
           var HUB = {
             title: 'Hub title',
-            components: ["Opening paragraph", {
+            components: ['Opening paragraph', {
               type: 'heading',
               size: 'l',
               content: 'Hub heading'
-            }, "Closing paragraph", {
+            }, 'Closing paragraph', {
               use: 'a'
             }]
           };
@@ -78,19 +78,30 @@ describe('utils', function () {
               type: 'html',
               tagName: 'p',
               content: HUB.components[0]
-            }, HUB.components[1], {
+            }, _objectSpread(_objectSpread({}, HUB.components[1]), {}, {
+              full_path: HUB.components[1].fieldId
+            }), {
               type: 'html',
               tagName: 'p',
               content: HUB.components[2]
             }, _objectSpread(_objectSpread({
               use: 'a'
             }, A), {}, {
-              cya_label: A.label
+              cya_label: A.label,
+              full_path: A.fieldId
             })],
             formData: FORM_DATA
           });
         });
       });
+      describe("when the FormType is \"".concat(_models.FormTypes.TASK, "\""), function () {
+        it("should return the string \"".concat(_models.HubFormats.TASK, "\" when the format is set to \"").concat(_models.HubFormats.TASK, "\""), function () {
+          var HUB = {
+            format: _models.HubFormats.TASK
+          };
+          expect((0, _getFormHub.default)(_models.FormTypes.TASK, HUB, FORM_COMPONENTS, FORM_DATA)).toEqual(_models.HubFormats.TASK);
+        });
+      });
     });
   });
 });

package/dist/utils/Validate/additional/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _mustBeAfter = _interopRequireDefault(require("./mustBeAfter"));
+
+var _mustBeBefore = _interopRequireDefault(require("./mustBeBefore"));
+
+var _mustBeInThePast = _interopRequireDefault(require("./mustBeInThePast"));
+
+var _mustBeInTheFuture = _interopRequireDefault(require("./mustBeInTheFuture"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Local imports
+var functions = {
+  mustBeAfter: _mustBeAfter.default,
+  mustBeBefore: _mustBeBefore.default,
+  mustBeInThePast: _mustBeInThePast.default,
+  mustBeInTheFuture: _mustBeInTheFuture.default
+};
+
+var additionalValidation = function additionalValidation(value, config) {
+  var fn = functions[config.function];
+
+  if (typeof fn === 'function') {
+    return fn(value, config) ? undefined : config.message;
+  }
+
+  return undefined;
+};
+
+var runAdditionalComponentValidation = function runAdditionalComponentValidation(component, value) {
+  // We only care when we have a value - if we don't have one but want one, set `required: true`.
+  if (!!value) {
+    if (Array.isArray(component.additionalValidation)) {
+      var error = undefined;
+      component.additionalValidation.forEach(function (config) {
+        // If we've already encountered an error, don't run any more validators.
+        if (!error) {
+          error = additionalValidation(value, config);
+        }
+      });
+      return error;
+    }
+  }
+
+  return undefined;
+};
+
+var _default = runAdditionalComponentValidation;
+exports.default = _default;

package/dist/utils/Validate/additional/index.test.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));
+
+var _utils = require("./utils");
+
+var _index = _interopRequireDefault(require("./index"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+_dayjs.default.extend(_customParseFormat.default);
+
+describe('utils', function () {
+  describe('Validate', function () {
+    describe('additional', function () {
+      it('should apply optional validators when specified', function () {
+        var COMPONENT = {
+          additionalValidation: [{
+            function: 'mustBeAfter',
+            value: 3,
+            unit: 'day',
+            message: 'Date must be more than 3 days in the future'
+          }]
+        };
+        var VALUE = (0, _dayjs.default)().add(1, 'day').format(_utils.DATE_FORMAT);
+        expect((0, _index.default)(COMPONENT, VALUE)).toEqual('Date must be more than 3 days in the future');
+      });
+      it('should apply multiple optional validators when specified', function () {
+        var COMPONENT = {
+          additionalValidation: [{
+            function: 'mustBeAfter',
+            value: 100,
+            unit: 'day',
+            message: 'Date must be more than 100 days in the future'
+          }, {
+            function: 'mustBeBefore',
+            value: 200,
+            unit: 'day',
+            message: 'Date must be less than 200 days in the future'
+          }]
+        };
+        var VALUE = (0, _dayjs.default)().add(250, 'day').format(_utils.DATE_FORMAT);
+        expect((0, _index.default)(COMPONENT, VALUE)).toEqual('Date must be less than 200 days in the future');
+      });
+      it('should apply multiple optional validators when specified and return undefined if all are passed', function () {
+        var COMPONENT = {
+          additionalValidation: [{
+            function: 'mustBeAfter',
+            value: 100,
+            unit: 'day',
+            message: 'Date must be more than 100 days in the future'
+          }, {
+            function: 'mustBeBefore',
+            value: 200,
+            unit: 'day',
+            message: 'Date must be less than 200 days in the future'
+          }, {
+            function: 'mustBeInTheFuture',
+            message: 'Date must be in the future'
+          }]
+        };
+        var VALUE = (0, _dayjs.default)().add(150, 'day').format(_utils.DATE_FORMAT);
+        expect((0, _index.default)(COMPONENT, VALUE)).toEqual(undefined);
+      });
+    });
+  });
+});

package/dist/utils/Validate/additional/mustBeAfter.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Global imports
+// Local imports
+_dayjs.default.extend(_customParseFormat.default);
+/**
+ * Function returns true if the date string parameter is for a date more than ('is before') N months
+ * in the past, where N is the number of months parameter
+ * NOTE:  the one minute reduction on the threshold date is a workaround for as apparent bug in the
+ * day.js isBefore() function when checking on 'same dates'
+ * @param {string} date - date string in a valid date format e.g. DD-MM-YYYY
+ * @param {string} config.unit - day, month or year
+ * @param {number} config.value - number of the unit to be after
+ * @returns false if date is NOT after the no of months in the past.
+ */
+
+
+var mustBeAfter = function mustBeAfter(date, config) {
+  var dateToCompare = (0, _dayjs.default)().add(config.value, config.unit);
+  return (0, _dayjs.default)((0, _utils.formatString)(date), _utils.DATE_FORMAT).isAfter(dateToCompare);
+};
+
+var _default = mustBeAfter;
+exports.default = _default;

package/dist/utils/Validate/additional/mustBeAfter.test.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _mustBeAfter = _interopRequireDefault(require("./mustBeAfter"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+describe('utils', function () {
+  describe('Validate', function () {
+    describe('additional', function () {
+      describe('mustBeAfter', function () {
+        test('should return true given a date after the given number of months in the future', function () {
+          var date = (0, _dayjs.default)().add(3, 'month').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: 1,
+            unit: 'month'
+          });
+          expect(result).toEqual(true);
+        });
+        test('should return false given a date before the given number of months in the future', function () {
+          var date = (0, _dayjs.default)().add(3, 'month').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: 5,
+            unit: 'month'
+          });
+          expect(result).toEqual(false);
+        });
+        test('should return true given a date after the given number of months in the past', function () {
+          var date = (0, _dayjs.default)().add(-3, 'month').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: -5,
+            unit: 'month'
+          });
+          expect(result).toEqual(true);
+        });
+        test('should return false given a date before the given number of months in the past', function () {
+          var date = (0, _dayjs.default)().add(-10, 'month').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: -5,
+            unit: 'month'
+          });
+          expect(result).toEqual(false);
+        });
+        test('should return true given a date after the given number of years in the future', function () {
+          var date = (0, _dayjs.default)().add(3, 'year').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: 1,
+            unit: 'year'
+          });
+          expect(result).toEqual(true);
+        });
+        test('should return false given a date before the given number of years in the future', function () {
+          var date = (0, _dayjs.default)().add(15, 'year').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: 20,
+            unit: 'year'
+          });
+          expect(result).toEqual(false);
+        });
+        test('should return true given a date after the given number of years in the past', function () {
+          var date = (0, _dayjs.default)().add(-15, 'year').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: -20,
+            unit: 'year'
+          });
+          expect(result).toEqual(true);
+        });
+        test('should return false given a date before the given number of years in the past', function () {
+          var date = (0, _dayjs.default)().add(-25, 'year').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: -20,
+            unit: 'year'
+          });
+          expect(result).toEqual(false);
+        });
+        test('should return true given a date after the given number of days in the future', function () {
+          var date = (0, _dayjs.default)().add(3, 'day').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: 1,
+            unit: 'day'
+          });
+          expect(result).toEqual(true);
+        });
+        test('should return true given a date before the given number of days in the future', function () {
+          var date = (0, _dayjs.default)().add(250, 'day').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeAfter.default)(date, {
+            value: 275,
+            unit: 'day'
+          });
+          expect(result).toEqual(false);
+        });
+      });
+    });
+  });
+});

package/dist/utils/Validate/additional/mustBeBefore.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Global imports
+// Local imports
+_dayjs.default.extend(_customParseFormat.default);
+/**
+ * Function returns false if the date string parameter is for a date more than N in the future
+ * where N is the number of months parameter
+ * @param {string} dateToCheck - date string in a valid date format e.g. DD-MM-YYYY
+ * @param {string} config.unit - day, month or year
+ * @param {number} config.value - number of the unit to be before
+ * @returns true if date is not after the no of months in future.
+ */
+
+
+var mustBeBefore = function mustBeBefore(date, config) {
+  var dateToCompare = (0, _dayjs.default)().add(config.value, config.unit);
+  return (0, _dayjs.default)((0, _utils.formatString)(date), _utils.DATE_FORMAT).isBefore(dateToCompare);
+};
+
+var _default = mustBeBefore;
+exports.default = _default;

package/dist/utils/Validate/additional/mustBeBefore.test.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _mustBeBefore = _interopRequireDefault(require("./mustBeBefore"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+describe('utils', function () {
+  describe('Validate', function () {
+    describe('additional', function () {
+      describe('mustBeBefore', function () {
+        test('should return true given a date before the given number of months in the future', function () {
+          var date = (0, _dayjs.default)().add(1, 'month').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeBefore.default)(date, {
+            value: 3,
+            unit: 'month'
+          });
+          expect(result).toEqual(true);
+        });
+        test('should return false given a date after the given number of months in the future', function () {
+          var date = (0, _dayjs.default)().add(5, 'month').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeBefore.default)(date, {
+            value: 3,
+            unit: 'month'
+          });
+          expect(result).toEqual(false);
+        });
+        test('should return true given a date before the given number of years in the future', function () {
+          var date = (0, _dayjs.default)().add(1, 'year').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeBefore.default)(date, {
+            value: 3,
+            unit: 'year'
+          });
+          expect(result).toEqual(true);
+        });
+        test('should return false given a date after the given number of years in the future', function () {
+          var date = (0, _dayjs.default)().add(20, 'year').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeBefore.default)(date, {
+            value: 15,
+            unit: 'year'
+          });
+          expect(result).toEqual(false);
+        });
+        test('should return true given a date before the given number of days in the future', function () {
+          var date = (0, _dayjs.default)().add(1, 'day').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeBefore.default)(date, {
+            value: 3,
+            unit: 'day'
+          });
+          expect(result).toEqual(true);
+        });
+        test('should return true given a date after the given number of days in the future', function () {
+          var date = (0, _dayjs.default)().add(275, 'day').format(_utils.DATE_FORMAT);
+          var result = (0, _mustBeBefore.default)(date, {
+            value: 250,
+            unit: 'day'
+          });
+          expect(result).toEqual(false);
+        });
+      });
+    });
+  });
+});

package/dist/utils/Validate/additional/mustBeInTheFuture.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));
+
+var _isToday = _interopRequireDefault(require("dayjs/plugin/isToday"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Global Imports
+//Local imports
+_dayjs.default.extend(_customParseFormat.default);
+
+_dayjs.default.extend(_isToday.default);
+/**
+ * Function returns true if the date parameter is a date after today, else returns false
+ * @param {string} date - date string e.g. '03-12-2021'
+ * @param {boolean} config.todayAllowed - true if today should be a valid date
+ * @returns true if date is after current date
+ */
+
+
+var mustBeInTheFuture = function mustBeInTheFuture(date, config) {
+  var afterToday = (0, _dayjs.default)((0, _utils.formatString)(date), _utils.DATE_FORMAT).isAfter((0, _dayjs.default)());
+
+  if (afterToday) {
+    return true;
+  }
+
+  return !!(config !== null && config !== void 0 && config.todayAllowed) && (0, _dayjs.default)((0, _utils.formatString)(date), _utils.DATE_FORMAT).isToday();
+};
+
+var _default = mustBeInTheFuture;
+exports.default = _default;

package/dist/utils/Validate/additional/mustBeInTheFuture.test.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _mustBeInTheFuture = _interopRequireDefault(require("./mustBeInTheFuture"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+describe('utils', function () {
+  describe('Validate', function () {
+    describe('additional', function () {
+      describe('mustBeInTheFuture', function () {
+        test('should return false given a date in the past', function () {
+          var result = (0, _mustBeInTheFuture.default)((0, _dayjs.default)().subtract(1, 'day').format('DD-MM-YYYY'));
+          expect(result).toEqual(false);
+        });
+        test('should return true given a date in the future', function () {
+          var result = (0, _mustBeInTheFuture.default)((0, _dayjs.default)().add(1, 'day').format('DD-MM-YYYY'));
+          expect(result).toEqual(true);
+        });
+        test('should return false given todays date', function () {
+          var result = (0, _mustBeInTheFuture.default)((0, _dayjs.default)().format('DD-MM-YYYY'));
+          expect(result).toEqual(false);
+        });
+        test('should return true given todays date if todayAllowed is true', function () {
+          var result = (0, _mustBeInTheFuture.default)((0, _dayjs.default)().format('DD-MM-YYYY'), {
+            todayAllowed: true
+          });
+          expect(result).toEqual(true);
+        });
+      });
+    });
+  });
+});

package/dist/utils/Validate/additional/mustBeInThePast.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));
+
+var _isToday = _interopRequireDefault(require("dayjs/plugin/isToday"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Global imports
+//Local imports
+_dayjs.default.extend(_customParseFormat.default);
+
+_dayjs.default.extend(_isToday.default);
+/**
+ * Function returns true if the date parameter is a date before today, else returns false
+ * dayjs counts today as before today so also cover same day inputs
+ * @param {string} date - date string e.g. '03-12-2021'
+ * @param {boolean} config.todayAllowed - true if today should be a valid date
+ * @returns true if date is before current date
+ */
+
+
+var mustBeInThePast = function mustBeInThePast(date, config) {
+  var beforeToday = (0, _dayjs.default)((0, _utils.formatString)(date), _utils.DATE_FORMAT).isBefore((0, _dayjs.default)());
+  var isToday = (0, _dayjs.default)((0, _utils.formatString)(date), _utils.DATE_FORMAT).isToday(); //dayjs classifies the current day as in the past so exclude it here
+
+  if (beforeToday && !isToday) {
+    return true;
+  }
+
+  return isToday && !!(config !== null && config !== void 0 && config.todayAllowed);
+};
+
+var _default = mustBeInThePast;
+exports.default = _default;

package/dist/utils/Validate/additional/mustBeInThePast.test.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _mustBeInThePast = _interopRequireDefault(require("./mustBeInThePast"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+describe('utils', function () {
+  describe('Validate', function () {
+    describe('additional', function () {
+      describe('mustBeInThePast', function () {
+        test('should return true given a date in the past', function () {
+          var result = (0, _mustBeInThePast.default)((0, _dayjs.default)().subtract(1, 'day').format('DD-MM-YYYY'));
+          expect(result).toEqual(true);
+        });
+        test('should return false given a date in the future', function () {
+          var result = (0, _mustBeInThePast.default)((0, _dayjs.default)().add(1, 'day').format('DD-MM-YYYY'));
+          expect(result).toEqual(false);
+        });
+        test('should return false given todays date', function () {
+          var result = (0, _mustBeInThePast.default)((0, _dayjs.default)().format('DD-MM-YYYY'));
+          expect(result).toEqual(false);
+        });
+        test('should return true given todays date if todayAllowed is true', function () {
+          var result = (0, _mustBeInThePast.default)((0, _dayjs.default)().format('DD-MM-YYYY'), {
+            todayAllowed: true
+          });
+          expect(result).toEqual(true);
+        });
+      });
+    });
+  });
+});

package/dist/utils/Validate/additional/utils.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formattedTime = exports.formatString = exports.DATE_FORMAT = void 0;
+
+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; }
+
+var isNumeric = function isNumeric(value) {
+  return /^-?\d+$/.test(value);
+};
+
+var formatString = function formatString(date) {
+  var _date$split = date.split('-'),
+      _date$split2 = _slicedToArray(_date$split, 3),
+      day = _date$split2[0],
+      month = _date$split2[1],
+      year = _date$split2[2];
+
+  return "".concat(formatInTwoDigits(day), "-").concat(formatInTwoDigits(month), "-").concat(year);
+};
+
+exports.formatString = formatString;
+
+var formattedTime = function formattedTime(time) {
+  var _time$split = time.split(':'),
+      _time$split2 = _slicedToArray(_time$split, 2),
+      hour = _time$split2[0],
+      minute = _time$split2[1];
+
+  return "".concat(formatInTwoDigits(hour), ":").concat(formatInTwoDigits(minute));
+};
+/**
+
+/**
+ * Prepends a leading zero if the 'date component' parameter contains only a single digit.
+ * if the parameter contains more than one digit it is returned unchanged.
+ * If the parameter contains a non-numeric value it returned as an empty string.
+ * @param {string} dateComponent - the value representing a day or month.
+ * @returns  the value (appended with a leading zero, if the value passed in was a single digit)
+ */
+
+
+exports.formattedTime = formattedTime;
+
+var formatInTwoDigits = function formatInTwoDigits(dateComponent) {
+  if (isNumeric(dateComponent)) {
+    return dateComponent.padStart(2, '0');
+  }
+
+  return '';
+};
+
+var DATE_FORMAT = 'DD-MM-YYYY';
+exports.DATE_FORMAT = DATE_FORMAT;

package/dist/utils/Validate/index.js

@@ -7,20 +7,26 @@ exports.default = void 0;
 
 var _validateComponent = _interopRequireDefault(require("./validateComponent"));
 
+var _validateDate = _interopRequireDefault(require("./validateDate"));
+
 var _validateEmail = _interopRequireDefault(require("./validateEmail"));
 
 var _validatePage = _interopRequireDefault(require("./validatePage"));
 
 var _validateRequired = _interopRequireDefault(require("./validateRequired"));
 
+var _validateTime = _interopRequireDefault(require("./validateTime"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // Local imports
 var Validate = {
   component: _validateComponent.default,
   email: _validateEmail.default,
+  date: _validateDate.default,
   page: _validatePage.default,
-  required: _validateRequired.default
+  required: _validateRequired.default,
+  time: _validateTime.default
 };
 var _default = Validate;
 exports.default = _default;