n4s 2.2.0-rc.1 → 4.0.0-dev-e266d9

package/ensure.umd.development.js

@@ -1,424 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-  typeof define === 'function' && define.amd ? define(factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.ensure = factory());
-}(this, (function () { 'use strict';
-
-  function _extends() {
-    _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;
-    };
-
-    return _extends.apply(this, arguments);
-  }
-
-  function throwError(message) {
-    throw new Error(`[${"ensure"}]: ${message}`);
-  }
-
-  const isRule = (rulesObject, name) => {
-    const ruleExists = Object.prototype.hasOwnProperty.call(rulesObject, name) && typeof rulesObject[name] === 'function';
-
-    if (!ruleExists) {
-      throwError(`Rule "${name}" was not found in rules object. Make sure you typed it correctly.`);
-    }
-
-    return ruleExists;
-  };
-
-  const GLOBAL_OBJECT = Function('return this')();
-
-  const proxySupported = () => typeof GLOBAL_OBJECT.Proxy === 'function';
-
-  function bindNot(fn) {
-    return function () {
-      return !fn.apply(this, arguments);
-    };
-  }
-
-  function endsWith(value, arg1) {
-    return typeof value === 'string' && typeof arg1 === 'string' && value.endsWith(arg1);
-  }
-  const doesNotEndWith = bindNot(endsWith);
-
-  function equals(value, arg1) {
-    return value === arg1;
-  }
-  const notEquals = bindNot(equals);
-
-  function isNumeric(value) {
-    const result = !isNaN(parseFloat(value)) && !isNaN(Number(value)) && isFinite(value);
-    return Boolean(result);
-  }
-  const isNotNumeric = bindNot(isNumeric);
-
-  function greaterThan(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) > Number(arg1);
-  }
-
-  function greaterThanOrEquals(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) >= Number(arg1);
-  }
-
-  function inside(value, arg1) {
-    if (Array.isArray(arg1) && ['string', 'number', 'boolean'].indexOf(typeof value) !== -1) {
-      return arg1.indexOf(value) !== -1;
-    } // both value and arg1 are strings
-
-
-    if (typeof arg1 === 'string' && typeof value === 'string') {
-      return arg1.indexOf(value) !== -1;
-    }
-
-    return false;
-  }
-  const notInside = bindNot(inside);
-
-  function isArray(value) {
-    return Boolean(Array.isArray(value));
-  }
-  const isNotArray = bindNot(isArray);
-
-  function lessThanOrEquals(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) <= Number(arg1);
-  }
-
-  function isBetween(value, min, max) {
-    return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
-  }
-  const isNotBetween = bindNot(isBetween);
-
-  function isEmpty(value) {
-    if (!value) {
-      return true;
-    } else if (isNumeric(value)) {
-      return value === 0;
-    } else if (Object.prototype.hasOwnProperty.call(value, 'length')) {
-      return value.length === 0;
-    } else if (typeof value === 'object') {
-      return Object.keys(value).length === 0;
-    } else {
-      return true;
-    }
-  }
-  const isNotEmpty = bindNot(isEmpty);
-
-  /**
-   * Validates that a given value is an even number
-   * @param {Number|String} value Value to be validated
-   * @return {Boolean}
-   */
-
-  const isEven = value => {
-    if (!isNumeric(value)) {
-      return false;
-    }
-
-    return value % 2 === 0;
-  };
-
-  function isNaN$1(value) {
-    return Number.isNaN(value);
-  }
-  const isNotNaN = bindNot(isNaN$1);
-
-  function isNegative(value) {
-    if (isNumeric(value)) {
-      return Number(value) < 0;
-    }
-
-    return false;
-  }
-  const isPositive = bindNot(isNegative);
-
-  function isNull(value) {
-    return value === null;
-  }
-  const isNotNull = bindNot(isNull);
-
-  function isNumber(value) {
-    return Boolean(typeof value === 'number');
-  }
-  const isNotNumber = bindNot(isNumber);
-
-  /**
-   * Validates that a given value is an odd number
-   * @param {Number|String} value Value to be validated
-   * @return {Boolean}
-   */
-
-  const isOdd = value => {
-    if (!isNumeric(value)) {
-      return false;
-    }
-
-    return value % 2 !== 0;
-  };
-
-  function isString(value) {
-    return Boolean(typeof value === 'string');
-  }
-  const isNotString = bindNot(isString);
-
-  function isTruthy(value) {
-    return !!value;
-  }
-  const isFalsy = bindNot(isTruthy);
-
-  function isUndefined(value) {
-    return value === undefined;
-  }
-  const isNotUndefined = bindNot(isUndefined);
-
-  function lengthEquals(value, arg1) {
-    return value.length === arg1;
-  }
-  const lengthNotEquals = bindNot(lengthEquals);
-
-  function lessThan(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) < Number(arg1);
-  }
-
-  function longerThan(value, arg1) {
-    return value.length > arg1;
-  }
-
-  function longerThanOrEquals(value, arg1) {
-    return value.length >= arg1;
-  }
-
-  function matches(value, regex) {
-    if (regex instanceof RegExp) {
-      return regex.test(value);
-    } else if (typeof regex === 'string') {
-      return new RegExp(regex).test(value);
-    } else {
-      return false;
-    }
-  }
-  const notMatches = bindNot(matches);
-
-  function numberEquals(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) === Number(arg1);
-  }
-  const numberNotEquals = bindNot(numberEquals);
-
-  function shorterThan(value, arg1) {
-    return value.length < arg1;
-  }
-
-  function shorterThanOrEquals(value, arg1) {
-    return value.length <= arg1;
-  }
-
-  function startsWith(value, arg1) {
-    return typeof value === 'string' && typeof arg1 === 'string' && value.startsWith(arg1);
-  }
-  const doesNotStartWith = bindNot(startsWith);
-
-  var rules = {
-    doesNotEndWith,
-    doesNotStartWith,
-    endsWith,
-    equals,
-    greaterThan,
-    greaterThanOrEquals,
-    gt: greaterThan,
-    gte: greaterThanOrEquals,
-    inside,
-    isArray,
-    isBetween,
-    isEmpty,
-    isEven,
-    isFalsy,
-    isNaN: isNaN$1,
-    isNegative,
-    isNotArray,
-    isNotBetween,
-    isNotEmpty,
-    isNotNaN,
-    isNotNull,
-    isNotNumber,
-    isNotNumeric,
-    isNotString,
-    isNotUndefined,
-    isNull,
-    isNumber,
-    isNumeric,
-    isOdd,
-    isPositive,
-    isString,
-    isTruthy,
-    isUndefined,
-    lengthEquals,
-    lengthNotEquals,
-    lessThan,
-    lessThanOrEquals,
-    longerThan,
-    longerThanOrEquals,
-    lt: lessThan,
-    lte: lessThanOrEquals,
-    matches,
-    notEquals,
-    notInside,
-    notMatches,
-    numberEquals,
-    numberNotEquals,
-    shorterThan,
-    shorterThanOrEquals,
-    startsWith
-  };
-
-  function validateResult(result, rule) {
-    if (typeof result !== 'boolean' && (!result || typeof result.pass !== 'boolean')) {
-      throwError(`${rule.name} wrong return value for the rule please check that the return is valid`);
-    }
-  } // for easier testing and mocking
-
-  function getDefaultResult(value, rule) {
-    return {
-      message: formatResultMessage(rule, `invalid ${typeof value} value`)
-    };
-  }
-  function formatResultMessage(rule, msg) {
-    return `[${"ensure"}]/${rule.name} ${msg}`;
-  }
-  /**
-   * Transform the result of a rule into a standard format
-   * @param {string} interfaceName to be used in the messages
-   * @param {*} result of the rule
-   * @param {Object} options
-   * @param {function} options.rule
-   * @param {*} options.value
-   * @returns {Object} result
-   * @returns {string} result.message
-   * @returns {boolean} result.pass indicates if the test passes or not
-   */
-
-  function transformResult(result, {
-    rule,
-    value
-  }) {
-    const defaultResult = getDefaultResult(value, rule);
-    validateResult(result, rule);
-
-    if (typeof result === 'boolean') {
-      return _extends({}, defaultResult, {
-        pass: result
-      });
-    } else {
-      const formattedResult = {
-        pass: result.pass
-      };
-
-      if (result.message) {
-        formattedResult.message = formatResultMessage(rule, typeof result.message === 'function' ? result.message() : result.message);
-      }
-
-      return _extends({}, defaultResult, formattedResult);
-    }
-  }
-
-  /**
-   * Run a single rule against ensured value (e.g. `isNumber()`)
-   * @param {Function} rule - rule to run
-   * @param {Any} value
-   * @param {Array} args list of arguments sent from consumer
-   * @return {Boolean}
-   */
-
-  function runner(rule, value, ...args) {
-    try {
-      const result = rule(value, ...args);
-      return transformResult(result, {
-        rule,
-        value
-      }).pass;
-    } catch (err) {
-      return false;
-    }
-  }
-
-  /**
-   * Accepts list of registered rules and returns a test function
-   * That runs against them to return a boolean
-   *
-   * @param {Array} registeredRules
-   * @return {Function} test function
-   */
-
-  const createTestFn = registeredRules => value => registeredRules.every(({
-    name,
-    args
-  }) => runner(rulesObject[name], value, ...args));
-
-  let ensure, rulesList;
-
-  const rulesObject = _extends({}, rules);
-
-  if (proxySupported()) {
-    ensure = () => {
-      const registeredRules = [];
-      const proxy = new Proxy(rulesObject, {
-        get: (rules, ruleName) => {
-          if (ruleName === 'test') {
-            return createTestFn(registeredRules);
-          }
-
-          if (!isRule(rulesObject, ruleName)) {
-            return;
-          }
-
-          return (...args) => {
-            registeredRules.push({
-              name: ruleName,
-              args
-            });
-            return proxy;
-          };
-        }
-      });
-      return proxy;
-    };
-  }
-
-  rulesList = Object.keys(rulesObject);
-
-  ensure = () => {
-    const registeredRules = [];
-    return rulesList.reduce((allRules, ruleName) => Object.assign(allRules, _extends({}, isRule(rulesObject, ruleName) && {
-      [ruleName]: (...args) => {
-        registeredRules.push({
-          name: ruleName,
-          args
-        });
-        return allRules;
-      }
-    })), {
-      test: createTestFn(registeredRules)
-    });
-  };
-
-  ensure.extend = customRules => {
-    Object.assign(rulesObject, customRules);
-
-    if (proxySupported()) {
-      rulesList = Object.keys(rulesObject);
-    }
-  };
-
-  var ensure$1 = ensure;
-
-  return ensure$1;
-
-})));