@digigov/form 0.6.9 → 0.7.1

package/validators/index.js

@@ -0,0 +1,181 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getYUPTypeMap = void 0;
+exports.useValidationSchema = useValidationSchema;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var yup = _interopRequireWildcard(require("yup"));
+
+var _react = require("react");
+
+var _dayjs = _interopRequireDefault(require("dayjs"));
+
+var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));
+
+var _utils = require("@digigov/form/validators/utils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+_dayjs["default"].extend(_customParseFormat["default"]);
+
+var VALID_DATE_FORMATS = ['DD/MM/YYYY'];
+var DATE_CACHE = {};
+
+var getDate = function getDate(v) {
+  return DATE_CACHE[v] ? DATE_CACHE[v] : (0, _dayjs["default"])(v, VALID_DATE_FORMATS, true);
+};
+
+var getYUPTypeMap = function getYUPTypeMap() {
+  var yupTypeMap = {
+    file: function file(field) {
+      return yup.mixed().transform(function (value) {
+        if (!value.length) {
+          return null;
+        }
+
+        return value;
+      }).nullable().test((0, _utils.FILE_MAX_SIZE_VALIDATOR)(field));
+    },
+    string: yup.string,
+    text: yup.string,
+    "boolean": yup["boolean"],
+    object: function object(field) {
+      return (0, _utils.getYupObjectShape)(field.extra.fields, yupTypeMap);
+    },
+    array: function array(field) {
+      if ((0, _typeof2["default"])(field.extra.of) === 'object') {
+        // else if the field is an object then it is a scalar type
+        // eg. number, string etc.
+        return yup.array().of(yupTypeMap[field.extra.of.type](field.extra.of)); // .min(field.extra.min)
+        // .max(field.extra.max)
+        // .length(field.extra.length)
+        // .required(field.required);
+      } else if (typeof field.extra.of === 'string') {
+        return yup.array().of(yupTypeMap[field.extra.of]());
+      } else {
+        // in any other case it will be string
+        return yup.array().of(yup.string());
+      }
+    },
+    "int": function int() {
+      return yup.number().typeError('form.error.number').positive('form.error.positive_number');
+    },
+    email: function email() {
+      return yup.string().email('form.error.email');
+    },
+    afm: function afm() {
+      return yup.string().test(_utils.AFM_VALIDATOR);
+    },
+    uuid4: function uuid4() {
+      return yup.string().test(_utils.UUID4_VALIDATOR);
+    },
+    iban: function iban(field) {
+      return yup.string().test((0, _utils.IBAN_VALIDATOR)(field));
+    },
+    postal_code: function postal_code(field) {
+      return yup.string().test((0, _utils.POSTALCODE_VALIDATOR)(field));
+    },
+    mobile_phone: function mobile_phone() {
+      return yup.string().test(_utils.MOBILE_PHONE_VALIDATOR);
+    },
+    phone_number: function phone_number(field) {
+      return yup.string().test((0, _utils.PHONE_NUMBER_VALIDATOR)(field));
+    },
+    'choice:multiple': function choiceMultiple() {
+      return yup.array().of(yup.string()).nullable();
+    },
+    'choice:single': function choiceSingle() {
+      return yup.string().nullable();
+    },
+    date: function date(field) {
+      var simpleDate = yup.string().nullable(true).test('date', 'form.error.date.invalid', function (value) {
+        if (!value) return true;
+        value = getDate(value);
+        return value.isValid();
+      });
+      var params = field.extra || {};
+
+      if (params.max) {
+        var maxDate;
+
+        if (params.max === 'now') {
+          var today = new Date();
+          maxDate = new Date(today);
+        } else {
+          maxDate = getDate(params.max).toDate();
+        }
+
+        var maxNextDate = new Date(maxDate);
+        maxNextDate.setDate(maxDate.getDate() + 1);
+        simpleDate = simpleDate.test({
+          name: 'earlier-than',
+          message: {
+            key: 'form.error.date.earlier_than',
+            context: {
+              maxDate: maxNextDate.toLocaleDateString()
+            }
+          },
+          test: function test(value) {
+            if (!value) return true;
+            value = getDate(value);
+            var isValid = +value.toDate() < +maxDate;
+            return isValid;
+          }
+        });
+      }
+
+      if (params.min) {
+        var minDate;
+
+        if (params.min === 'now') {
+          var _today = new Date();
+
+          minDate = new Date(_today);
+        } else {
+          minDate = getDate(params.min).toDate();
+        }
+
+        var minPreviousDate = new Date(minDate);
+        minPreviousDate.setDate(minDate.getDate() - 1);
+        simpleDate = simpleDate.test({
+          name: 'later-than',
+          message: {
+            key: 'form.error.date.later_than',
+            context: {
+              minDate: minPreviousDate.toLocaleDateString()
+            }
+          },
+          test: function test(value) {
+            if (!value) return true;
+            value = getDate(value);
+            var isValid = +value.toDate() > +minDate;
+            return isValid;
+          }
+        });
+      }
+
+      return simpleDate;
+    }
+  };
+  return yupTypeMap;
+};
+
+exports.getYUPTypeMap = getYUPTypeMap;
+
+// Create a yup validation schema from given fields input
+function useValidationSchema(fields, validatorRegistry) {
+  return (0, _react.useMemo)(function () {
+    var yupTypeMap = getYUPTypeMap();
+    return (0, _utils.getYupObjectShape)(fields, yupTypeMap, validatorRegistry);
+  }, []);
+}

package/validators/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/validators/utils/afm.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AFM_VALIDATOR = void 0;
+exports.validateAFM = validateAFM;
+
+function validateAFM(afm) {
+  if (afm.length !== 9) {
+    // "afm should be 9 digits"
+    return false;
+  }
+
+  if (!/^\d+$/.test(afm)) {
+    // "This is not a number"
+    return false;
+  }
+
+  if (afm === '0'.repeat(9)) {
+    // "This is zero number (000000000)"
+    return false;
+  }
+
+  var sum = afm.substring(0, 8).split('').reduce(function (s, v, i) {
+    return s + (parseInt(v) << 8 - i);
+  }, 0);
+  var calc = sum % 11;
+  var d9 = parseInt(afm[8]);
+  var valid = calc % 10 === d9;
+  return valid;
+}
+
+var AFM_VALIDATOR = {
+  name: 'afm-validator',
+  message: 'form.error.afm',
+  test: function test(value) {
+    if (value) {
+      return validateAFM(value);
+    }
+
+    return true;
+  }
+};
+exports.AFM_VALIDATOR = AFM_VALIDATOR;

package/validators/utils/file.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FILE_MAX_SIZE_VALIDATOR = void 0;
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+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; }
+
+var DEFAULT_FILE_MAX_SIZE = 10000000;
+
+var FILE_MAX_SIZE_VALIDATOR = function FILE_MAX_SIZE_VALIDATOR(field) {
+  return {
+    name: 'file-max-size-validator',
+    message: 'form.error.file_size',
+    test: function test(value) {
+      if (field.extra && field.extra.maxSize && value) {
+        var _iterator = _createForOfIteratorHelper(value),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var file = _step.value;
+
+            if (file.size >= field.extra.maxSize) {
+              return false;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      } else if (value) {
+        var _iterator2 = _createForOfIteratorHelper(value),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _file = _step2.value;
+
+            if (_file.size >= DEFAULT_FILE_MAX_SIZE) {
+              return false;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+
+      return true;
+    }
+  };
+};
+
+exports.FILE_MAX_SIZE_VALIDATOR = FILE_MAX_SIZE_VALIDATOR;

package/validators/utils/iban.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IBAN_VALIDATOR = void 0;
+exports.validateIban = validateIban;
+
+function validateIban(value, countryCode) {
+  value = value.replace(/\s/g, '').replace(/-/g, '');
+
+  if (value.match(/^[0-9]*$/i)) {
+    // this is for greek iban without the country code
+    if (value.length !== 25) {
+      return false;
+    }
+  } else {
+    value = value.toUpperCase();
+
+    if (countryCode) {
+      if (!value.startsWith(countryCode.toUpperCase())) {
+        return false;
+      }
+
+      if (value.length === ibanCountryCodesLengths[countryCode.toUpperCase()]) {
+        return true;
+      }
+    }
+
+    if (value.length !== 27) {
+      // this is for greek iban
+      return false;
+    }
+  }
+
+  return true;
+}
+
+var IBAN_VALIDATOR = function IBAN_VALIDATOR(field) {
+  var _field$extra;
+
+  var countryCode = field === null || field === void 0 ? void 0 : (_field$extra = field.extra) === null || _field$extra === void 0 ? void 0 : _field$extra.country;
+  return {
+    name: 'iban-validator',
+    message: 'form.error.iban',
+    test: function test(value) {
+      if (!value) {
+        return true;
+      }
+
+      return validateIban(value, countryCode);
+    }
+  };
+};
+
+exports.IBAN_VALIDATOR = IBAN_VALIDATOR;
+var ibanCountryCodesLengths = {
+  AD: 24,
+  AT: 20,
+  AZ: 28,
+  BH: 22,
+  BY: 28,
+  BE: 16,
+  BA: 20,
+  BR: 29,
+  BG: 22,
+  CR: 22,
+  HR: 21,
+  CY: 28,
+  CZ: 24,
+  DK: 18,
+  DO: 28,
+  EG: 29,
+  SV: 28,
+  EE: 20,
+  FO: 18,
+  FI: 18,
+  FR: 27,
+  GE: 22,
+  DE: 22,
+  GI: 23,
+  GR: 27,
+  GL: 18,
+  GT: 28,
+  VA: 22,
+  HU: 28,
+  IS: 26,
+  IQ: 23,
+  IE: 22,
+  IL: 23,
+  IT: 27,
+  JO: 30,
+  KZ: 20,
+  XK: 20,
+  KW: 30,
+  LV: 21,
+  LB: 28,
+  LI: 21,
+  LT: 20,
+  LU: 20,
+  MT: 31,
+  MR: 27,
+  MU: 30,
+  MD: 24,
+  MC: 27,
+  ME: 22,
+  NL: 18,
+  MK: 19,
+  NO: 15,
+  PK: 24,
+  PS: 29,
+  PL: 28,
+  PT: 25,
+  QA: 29,
+  RO: 24,
+  LC: 32,
+  SM: 27,
+  ST: 25,
+  SA: 24,
+  RS: 22,
+  SC: 31,
+  SK: 24,
+  SI: 19,
+  ES: 24,
+  SE: 24,
+  CH: 21,
+  TL: 23,
+  TN: 24,
+  TR: 26,
+  UA: 29,
+  AE: 23,
+  GB: 22,
+  VG: 24
+};

package/validators/utils/index.js

@@ -0,0 +1,210 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  getYupField: true,
+  computeShape: true,
+  getYupObjectShape: true
+};
+exports.computeShape = computeShape;
+exports.getYupField = getYupField;
+exports.getYupObjectShape = getYupObjectShape;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var yup = _interopRequireWildcard(require("yup"));
+
+var _afm = require("@digigov/form/validators/utils/afm");
+
+Object.keys(_afm).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _afm[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _afm[key];
+    }
+  });
+});
+
+var _file = require("@digigov/form/validators/utils/file");
+
+Object.keys(_file).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _file[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _file[key];
+    }
+  });
+});
+
+var _iban = require("@digigov/form/validators/utils/iban");
+
+Object.keys(_iban).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _iban[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _iban[key];
+    }
+  });
+});
+
+var _phone = require("@digigov/form/validators/utils/phone");
+
+Object.keys(_phone).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _phone[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _phone[key];
+    }
+  });
+});
+
+var _postal_code = require("@digigov/form/validators/utils/postal_code");
+
+Object.keys(_postal_code).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _postal_code[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _postal_code[key];
+    }
+  });
+});
+
+var _uuid = require("@digigov/form/validators/utils/uuid4");
+
+Object.keys(_uuid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _uuid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _uuid[key];
+    }
+  });
+});
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function getYupField(field, yupTypeMap) {
+  var yupField = yupTypeMap[field.type] || yupTypeMap.string;
+  return yupField(field);
+}
+
+function computeShape(fields, yupTypeMap, validatorRegistry) {
+  var fieldSchemas = {};
+  var objectFields = {};
+  fields.forEach(function (field) {
+    if (field.key.includes('.')) {
+      var _field$key$split = field.key.split(/\.(.+)/),
+          _field$key$split2 = (0, _slicedToArray2["default"])(_field$key$split, 2),
+          objectKey = _field$key$split2[0],
+          fieldKey = _field$key$split2[1];
+
+      if (!objectFields[objectKey]) {
+        objectFields[objectKey] = [];
+      }
+
+      objectFields[objectKey].push((0, _extends2["default"])({}, field, {
+        key: fieldKey
+      }));
+      return;
+    }
+
+    var yupField = getYupField(field, yupTypeMap);
+
+    if (field.condition) {
+      for (var key in field.condition) {
+        var then = void 0,
+            otherwise = void 0;
+
+        if (field.condition[key].then) {
+          var _field$condition$key$, _field$condition$key$2;
+
+          if (((_field$condition$key$ = field.condition[key].then) === null || _field$condition$key$ === void 0 ? void 0 : _field$condition$key$.required) === false) {
+            then = yupField;
+          } else if (((_field$condition$key$2 = field.condition[key].then) === null || _field$condition$key$2 === void 0 ? void 0 : _field$condition$key$2.required) === true) {
+            then = yupField.required('form.error.required');
+          }
+        }
+
+        if (field.condition[key]["else"]) {
+          var _field$condition$key$3, _field$condition$key$4;
+
+          if (((_field$condition$key$3 = field.condition[key]["else"]) === null || _field$condition$key$3 === void 0 ? void 0 : _field$condition$key$3.required) === false) {
+            otherwise = yupField;
+          } else if (((_field$condition$key$4 = field.condition[key]["else"]) === null || _field$condition$key$4 === void 0 ? void 0 : _field$condition$key$4.required) === true) {
+            otherwise = yupField.required('form.error.required');
+          }
+        }
+
+        if (then || otherwise) {
+          yupField = yupField.when(key, {
+            is: field.condition[key].is,
+            then: then,
+            otherwise: otherwise
+          });
+        }
+      }
+    } else if (field.required) {
+      yupField = yupField.required('form.error.required');
+    }
+
+    if (validatorRegistry && field.type && validatorRegistry[field.type]) {
+      validatorRegistry[field.type].forEach(function (validator) {
+        yupField = yupField.test(validator);
+      });
+    }
+
+    if (field.validators) {
+      field.validators.forEach(function (validator) {
+        yupField = yupField.test(validator);
+      });
+    }
+
+    fieldSchemas[field.key] = yupField;
+  });
+
+  for (var objectKey in objectFields) {
+    fieldSchemas[objectKey] = getYupObjectShape(objectFields[objectKey], yupTypeMap, validatorRegistry);
+  }
+
+  return fieldSchemas;
+}
+
+function getYupObjectShape( // eslint-disable-next-line @typescript-eslint/no-explicit-any
+fields, yupTypeMap, validatorRegistry) {
+  if (!fields.current) {
+    var fieldSchemas = computeShape(fields, yupTypeMap, validatorRegistry);
+    return yup.object().shape(fieldSchemas);
+  }
+
+  return yup.lazy(function () {
+    var fieldSchemas = computeShape(Object.values(fields.current), yupTypeMap, validatorRegistry);
+    return yup.object().shape(fieldSchemas);
+  });
+}