computed-types/lib/string.js

Runtime validation types for TypeScript.

"use strict";

exports.__esModule = true;
exports.default = exports.StringValidator = void 0;

var _Validator = _interopRequireDefault(require("./Validator"));

var _validations = require("./schema/validations");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class StringValidator extends _Validator.default {
  toLowerCase() {
    return this.transform(str => str.toLowerCase());
  }

  toUpperCase() {
    return this.transform(str => str.toUpperCase());
  }

  toLocaleLowerCase(...input) {
    return this.transform(str => str.toLocaleLowerCase(...input));
  }

  toLocaleUpperCase(...input) {
    return this.transform(str => str.toLocaleUpperCase(...input));
  }

  normalize(...input) {
    return this.transform(str => str.normalize(...input));
  }

  trim() {
    return this.transform(str => str.trim());
  }

  truncate(length) {
    return this.transform(str => str.length > length ? `${str.substring(0, length - 1)}…` : str);
  }

  min(length, error) {
    return this.test(str => str.length >= length, error || (str => new RangeError(`Expect length to be minimum of ${length} characters (actual: ${str.length})`)));
  }

  max(length, error) {
    return this.test(str => str.length <= length, error || (str => new RangeError(`Expect length to be maximum of ${length} characters (actual: ${str.length})`)));
  }

  between(minLength, maxLength, error) {
    return this.test(str => str.length >= minLength && str.length <= maxLength, error || (str => new RangeError(`Expect length to be between ${minLength} and ${maxLength} characters (actual: ${str.length})`)));
  }

  regexp(exp, error) {
    return this.transform((0, _validations.regexp)(exp, error));
  }

}

exports.StringValidator = StringValidator;
const string = new StringValidator((0, _validations.type)('string')).proxy();
var _default = string;
exports.default = _default;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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