x25 3.0.0 → 17.0.0

package/utility/strings-test.js

@@ -0,0 +1,216 @@
+"use strict";
+
+var _strings = require("./strings");
+
+// toTitle
+(function () {
+  describe("Test toTitle", function () {
+    var tests = [{
+      input: "",
+      output: ""
+    }, {
+      input: "cosovei",
+      output: "Cosovei"
+    }, {
+      input: "simona cosovei",
+      output: "Simona Cosovei"
+    }, {
+      input: "ștefănică țepeș",
+      output: "Ștefănică Țepeș"
+    }, {
+      input: "this is 4 long name 5",
+      output: "This Is 4 Long Name 5"
+    }];
+
+    var _loop = function _loop(_ref) {
+      var input = _ref.input,
+          output = _ref.output;
+
+      describe("Given the raw string \"" + input + "\"", function () {
+        it("should be transformed to \"" + output + "\"", function () {
+          expect((0, _strings.toTitle)(input)).toEqual(output);
+        });
+      });
+    };
+
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = tests[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var _ref = _step.value;
+
+        _loop(_ref);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  });
+})();
+
+// firstToUppercase
+(function () {
+  describe("Test firstToUppercase", function () {
+    var tests = [{
+      input: "",
+      output: ""
+    }, {
+      input: "sima",
+      output: "Sima"
+    }, {
+      input: "Simona Cosovei",
+      output: "Simona Cosovei"
+    }, {
+      input: "this is 4 long name 5",
+      output: "This is 4 long name 5"
+    }];
+
+    var _loop2 = function _loop2(_ref2) {
+      var input = _ref2.input,
+          output = _ref2.output;
+
+      describe("given \"" + input + "\"", function () {
+        it("should be transformed to \"" + output + "\"", function () {
+          expect((0, _strings.firstToUppercase)(input)).toEqual(output);
+        });
+      });
+    };
+
+    var _iteratorNormalCompletion2 = true;
+    var _didIteratorError2 = false;
+    var _iteratorError2 = undefined;
+
+    try {
+      for (var _iterator2 = tests[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var _ref2 = _step2.value;
+
+        _loop2(_ref2);
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+  });
+})();
+
+// toUpper
+(function () {
+  var tests = [{
+    input: "",
+    output: ""
+  }, {
+    input: "sima",
+    output: "SIMA"
+  }, {
+    input: "this is 4 long name 5",
+    output: "THIS IS 4 LONG NAME 5"
+  }];
+
+  var _loop3 = function _loop3(_ref3) {
+    var input = _ref3.input,
+        output = _ref3.output;
+
+    describe("given \"" + input + "\"", function () {
+      it("should be transformed to \"" + output + "\"", function () {
+        expect((0, _strings.toUpper)(input)).toEqual(output);
+      });
+    });
+  };
+
+  var _iteratorNormalCompletion3 = true;
+  var _didIteratorError3 = false;
+  var _iteratorError3 = undefined;
+
+  try {
+    for (var _iterator3 = tests[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+      var _ref3 = _step3.value;
+
+      _loop3(_ref3);
+    }
+  } catch (err) {
+    _didIteratorError3 = true;
+    _iteratorError3 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion3 && _iterator3.return) {
+        _iterator3.return();
+      }
+    } finally {
+      if (_didIteratorError3) {
+        throw _iteratorError3;
+      }
+    }
+  }
+})();
+
+// toLower
+(function () {
+  var tests = [{
+    input: "",
+    output: ""
+  }, {
+    input: "siMa",
+    output: "sima"
+  }, {
+    input: "This is 4 long Name 5",
+    output: "this is 4 long name 5"
+  }];
+
+  var _loop4 = function _loop4(_ref4) {
+    var input = _ref4.input,
+        output = _ref4.output;
+
+    describe("given \"" + input + "\"", function () {
+      it("should be transformed to \"" + output + "\"", function () {
+        expect((0, _strings.toLower)(input)).toEqual(output);
+      });
+    });
+  };
+
+  var _iteratorNormalCompletion4 = true;
+  var _didIteratorError4 = false;
+  var _iteratorError4 = undefined;
+
+  try {
+    for (var _iterator4 = tests[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+      var _ref4 = _step4.value;
+
+      _loop4(_ref4);
+    }
+  } catch (err) {
+    _didIteratorError4 = true;
+    _iteratorError4 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion4 && _iterator4.return) {
+        _iterator4.return();
+      }
+    } finally {
+      if (_didIteratorError4) {
+        throw _iteratorError4;
+      }
+    }
+  }
+})();

package/utility/strings.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/*
+ * 
+ * Simona Cosovei ---> Simona Cosovei
+ */
+var toTitle = exports.toTitle = function toTitle(str) {
+  var transform = function transform(txt) {
+    var firstPart = txt.charAt(0).toUpperCase(),
+        secondPart = txt.substr(1).toLowerCase();
+
+    return "" + firstPart + secondPart;
+  };
+
+  return str.replace(/(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+/g, transform);
+};
+
+// this is an example ---> This is an example
+var firstToUppercase = exports.firstToUppercase = function firstToUppercase(str) {
+  var firstPart = str.charAt(0).toUpperCase(),
+      secondPart = str.slice(1);
+
+  return "" + firstPart + secondPart;
+};
+
+var normalizeDiacritics = exports.normalizeDiacritics = function normalizeDiacritics(str) {
+  var chars = {
+    "ă": "a",
+    "â": "a",
+    "î": "i",
+    "ț": "t",
+    "ș": "s",
+
+    "Ă": "A",
+    "Â": "A",
+    "Î": "I",
+    "Ț": "T",
+    "Ș": "S"
+  };
+
+  return str.replace(/\u0103|\xE2|\xEE|\u021B|\u0219|\u0102|\xC2|\xCE|\u021A|\u0218/gi, function (matched) {
+    return chars[matched];
+  });
+};
+
+// This is ---> THIS IS
+var toUpper = exports.toUpper = function toUpper(str) {
+  return str.toUpperCase();
+};
+
+// This is ---> this is
+var toLower = exports.toLower = function toLower(str) {
+  return str.toLowerCase();
+};
+
+var formatBankAccount = exports.formatBankAccount = function formatBankAccount(raw) {
+
+  if (typeof raw === "undefined" || raw === "") {
+    return "";
+  }
+
+  var output = "";
+
+  var nrOfCharsPerGroup = 4,
+      withoutSpaces = raw.replace(/ /g, "");
+
+  for (var index = 0; index < withoutSpaces.length; index += 1) {
+    var currentChar = withoutSpaces.charAt(index);
+
+    if (output !== "" && index % nrOfCharsPerGroup === 0) {
+      output += " ";
+    }
+
+    output += currentChar;
+  }
+
+  return output;
+};
+
+var normalizeCompanyName = exports.normalizeCompanyName = function normalizeCompanyName(raw) {
+  return toTitle(raw).replace(/[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF][s\u017F]rl/gi, " S.R.L.").replace(/[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF][s\u017F]\.r\.l/gi, " S.R.L");
+};

package/utility/validation/common.js

@@ -0,0 +1,278 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateFields = exports.validatePassword = exports.validateHumanName = exports.validateResetToken = exports.validateCaptchaSolution = exports.validateID = exports.validateSelect = exports.validateString = exports.validateFloat = exports.validateDate = exports.validateOptionalDate = exports.validateEmail = exports.validateBankAccount = exports.validateCif = exports.validateHumanNid = undefined;
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _validate = require("./validate");
+
+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 errMessageSelectField = "Selectează câmpul";
+
+var limitTense = 19,
+    getNumberTense = function getNumberTense(value) {
+  return value > limitTense ? value + " de" : String(value);
+};
+
+var validateHumanNid = exports.validateHumanNid = function validateHumanNid() {
+  var optional = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  return function (value) {
+    var notValid = optional && typeof value !== "undefined" && value !== "" && !(0, _validate.isValidCNP)(value) || !optional && (typeof value === "undefined" || !(0, _validate.isValidCNP)(value)),
+        error = notValid ? "Trebuie un CNP valid" : null;
+
+    return {
+      notValid: notValid,
+      error: error
+    };
+  };
+};
+
+var validateCif = exports.validateCif = function validateCif(value) {
+  var notValid = typeof value === "undefined" || !(0, _validate.isValidCIF)(value),
+      error = notValid ? "Trebuie un cod valid de identificare fiscală" : null;
+
+  return {
+    notValid: notValid,
+    error: error
+  };
+};
+
+var validateBankAccount = exports.validateBankAccount = function validateBankAccount(value) {
+  var notValid = typeof value !== "undefined" && value !== "" && !(0, _validate.isValidBankAccount)(value),
+      error = notValid ? "Trebuie furnizat un IBAN valid" : null;
+
+  return {
+    notValid: notValid,
+    error: error
+  };
+};
+
+var validateEmail = exports.validateEmail = function validateEmail(_ref) {
+  var optional = _ref.optional;
+  return function (value) {
+    var notValid = optional && typeof value !== "undefined" && value !== "" && !(0, _validate.isValidEmail)(value) || !optional && (typeof value === "undefined" || !(0, _validate.isValidEmail)(value)),
+        error = notValid ? "Trebuie o adresă validă de e-mail" : null;
+
+    return {
+      notValid: notValid,
+      error: error
+    };
+  };
+};
+
+var validateOptionalDate = exports.validateOptionalDate = function validateOptionalDate(value) {
+  var notValid = !(typeof value === "undefined" || value === "" || value === null || (0, _validate.isValidDateStamp)(value)),
+      error = notValid ? "Trebuie o dată validă (ZZ.LL.ANUL)" : null;
+
+  return {
+    notValid: notValid,
+    error: error
+  };
+};
+
+var validateDate = exports.validateDate = function validateDate(value) {
+  var notValid = !(typeof value !== "undefined" && (0, _validate.isValidDateStamp)(value)),
+      error = notValid ? "Trebuie o dată validă (ZZ.LL.ANUL)" : null;
+
+  return {
+    notValid: notValid,
+    error: error
+  };
+};
+
+var isInt = function isInt(value) {
+  return !isNaN(value) && parseInt(Number(value), 10) === value && !isNaN(parseInt(value, 10));
+};
+
+var validateNumberRange = function validateNumberRange(_ref2) {
+  var min = _ref2.min,
+      max = _ref2.max,
+      value = _ref2.value,
+      integer = _ref2.integer;
+
+  if (typeof value !== "number") {
+    return false;
+  }
+
+  var numeric = Number(value),
+      hasMin = typeof min === "number",
+      hasMax = typeof max === "number";
+
+  return typeof value !== "undefined" && value !== "" && !isNaN(value) && (!integer || integer && isInt(value)) && (!hasMin || typeof min === "number" && numeric >= min) && (!hasMax || typeof max === "number" && numeric <= max);
+};
+
+var getNumberRangeError = function getNumberRangeError(_ref3) {
+  var min = _ref3.min,
+      max = _ref3.max,
+      integer = _ref3.integer;
+
+
+  var minTense = typeof min === "number" ? getNumberTense(min) : "",
+      maxTense = typeof max === "number" ? getNumberTense(max) : "",
+      range = typeof min === "number" && typeof max === "number" ? " \xEEntre " + minTense + " \u0219i " + maxTense : typeof max === "number" ? " p\xE2n\u0103 \xEEn " + maxTense : typeof min === "number" ? " mai mare ca " + minTense : "";
+
+  return "Trebuie un num\u0103r " + (integer ? "întreg" : "cu virgulă") + " " + range;
+};
+
+var validateFloat = exports.validateFloat = function validateFloat(props) {
+  return function (value) {
+    var min = props.min,
+        max = props.max,
+        optional = props.optional,
+        integer = props.integer;
+
+
+    var whenOptional = optional && !(typeof value === "undefined" || value === null || validateNumberRange({
+      min: min,
+      max: max,
+      value: value,
+      integer: integer
+    })),
+        whenRequired = !optional && !(typeof value !== "undefined" && value !== null && validateNumberRange({
+      min: min,
+      max: max,
+      value: value,
+      integer: integer
+    })),
+        notValid = whenOptional || whenRequired,
+        error = notValid ? getNumberRangeError({
+      min: min,
+      max: max,
+      integer: integer
+    }) : "";
+
+    return {
+      notValid: notValid,
+      error: error
+    };
+  };
+};
+
+var getStringTense = function getStringTense(_ref4) {
+  var min = _ref4.min,
+      max = _ref4.max,
+      what = _ref4.what;
+
+  var maxTense = max ? getNumberTense(max) : "",
+      minTense = min ? getNumberTense(min) : "",
+      isBetween = typeof max === "number" && typeof min === "number",
+      rangeError = isBetween ? "\xEEntre " + minTense + " \u0219i " + maxTense : typeof max === "number" ? "p\xE2n\u0103 \xEEn " + maxTense : typeof min === "number" ? "cel pu\u021Bin " + minTense : "";
+
+  return what + " are " + rangeError + " caractere";
+};
+
+var validateStringRange = function validateStringRange(_ref5) {
+  var min = _ref5.min,
+      max = _ref5.max,
+      value = _ref5.value;
+
+  if (typeof value !== "string") {
+    return false;
+  }
+
+  var length = typeof value === "undefined" ? 0 : value.length,
+      hasMin = typeof min === "number",
+      hasMax = typeof max === "number";
+
+  return (!hasMin || typeof min === "number" && length >= min) && (!hasMax || typeof max === "number" && length <= max);
+};
+
+var validateString = exports.validateString = function validateString(props) {
+  return function (value) {
+    var _props$what = props.what,
+        what = _props$what === undefined ? "Câmpul" : _props$what,
+        min = props.min,
+        max = props.max,
+        optional = props.optional;
+
+    var whenOptional = optional && !(typeof value === "undefined" || value === null || validateStringRange({
+      min: min,
+      max: max,
+      value: value
+    })),
+        whenRequired = !optional && !(typeof value !== "undefined" && value !== null && validateStringRange({
+      min: min,
+      max: max,
+      value: value
+    })),
+        notValid = whenOptional || whenRequired,
+        error = notValid ? getStringTense({
+      min: min,
+      max: max,
+      what: what
+    }) : "";
+
+    return {
+      notValid: notValid,
+      error: error
+    };
+  };
+};
+
+var validateSelect = exports.validateSelect = function validateSelect(message) {
+  return function (value) {
+    var notValid = typeof value === "undefined" || value === null || value === "",
+        error = notValid ? typeof message === "undefined" ? errMessageSelectField : message : null;
+
+    return {
+      notValid: notValid,
+      error: error
+    };
+  };
+};
+
+var validateID = exports.validateID = function validateID(message) {
+  return function (value) {
+    var notValid = !(typeof value === "number" && !isNaN(value)),
+        error = notValid ? typeof message === "undefined" ? errMessageSelectField : message : null;
+
+    return {
+      notValid: notValid,
+      error: error
+    };
+  };
+};
+
+var validateCaptchaSolution = exports.validateCaptchaSolution = function validateCaptchaSolution(value) {
+  var pattern = /^[0-9]{6}$/,
+      notValid = typeof value !== "undefined" && !pattern.test(value),
+      error = notValid ? "Codul are exact șase cifre" : null;
+
+  return {
+    notValid: notValid,
+    error: error
+  };
+};
+
+var validateResetToken = exports.validateResetToken = function validateResetToken(value) {
+  var tokenSize = 64,
+      notValid = typeof value === "undefined" || String(value).length !== tokenSize,
+      error = notValid ? "Codul nu este valid" : null;
+
+  return {
+    notValid: notValid,
+    error: error
+  };
+};
+
+var validateHumanName = exports.validateHumanName = validateString({
+  min: 3,
+  max: 40
+});
+
+var validatePassword = exports.validatePassword = validateString({
+  min: 6,
+  max: 25
+});
+
+var validateFields = exports.validateFields = function validateFields(fields, checker) {
+  return fields.reduce(function (accumulator, _ref6) {
+    var field = _ref6.field,
+        options = _ref6.options;
+    return _extends({}, accumulator, _defineProperty({}, field, checker(options)));
+  }, {});
+};

package/utility/validation/index.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _common = require("./common");
+
+Object.keys(_common).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _common[key];
+    }
+  });
+});
+
+var _specific = require("./specific");
+
+Object.keys(_specific).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _specific[key];
+    }
+  });
+});
+
+var _validate = require("./validate");
+
+Object.keys(_validate).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _validate[key];
+    }
+  });
+});
+
+
+var processErrors = function processErrors(_ref, _ref2) {
+  var error = _ref.error,
+      isArray = _ref.isArray,
+      _error = _ref._error,
+      arrayErrors = _ref.arrayErrors;
+  var field = _ref2.field,
+      errors = _ref2.errors;
+
+  if (isArray) {
+    if (arrayErrors) {
+      errors[field] = arrayErrors;
+    } else {
+      errors[field] = { _error: _error };
+    }
+  } else {
+    errors[field] = error;
+  }
+};
+
+var extractErrorsFromCheckers = exports.extractErrorsFromCheckers = function extractErrorsFromCheckers(checkers) {
+  return function (values) {
+    var errors = {};
+
+    for (var field in checkers) {
+      if (Object.prototype.hasOwnProperty.call(checkers, field)) {
+        var checker = checkers[field],
+            result = checker(values.get(field)),
+            notValid = result.notValid;
+
+
+        if (notValid) {
+          processErrors(result, {
+            field: field,
+            errors: errors
+          });
+        }
+      }
+    }
+
+    return errors;
+  };
+};
+
+var performValidateRows = exports.performValidateRows = function performValidateRows(items, checkers) {
+  var notValid = typeof items === "undefined" || items.size === 0;
+
+  if (notValid) {
+    return {
+      notValid: notValid,
+      _error: "Adaugă cel puțin un rând",
+      isArray: true
+    };
+  }
+
+  var arrayErrors = items.reduce(function (previous, item, key) {
+    previous[key] = extractErrorsFromCheckers(checkers)(item);
+
+    return previous;
+  }, []);
+
+  return {
+    notValid: true,
+    arrayErrors: arrayErrors,
+
+    isArray: true
+  };
+};

package/utility/validation/specific.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateDay = undefined;
+
+var _common = require("./common");
+
+var validateDay = exports.validateDay = (0, _common.validateFloat)({
+  min: 1,
+  max: 31,
+  integer: true
+});