n4s 5.0.0-dev-781e21 → 5.0.0-next-56be98

package/dist/cjs/n4s.development.js

@@ -5,15 +5,46 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var vestUtils = require('vest-utils');
 var context = require('context');
 
+const ctx = context.createCascade((ctxRef, parentContext) => {
+    const base = {
+        value: ctxRef.value,
+        meta: ctxRef.meta || {},
+    };
+    if (!parentContext) {
+        return vestUtils.assign(base, {
+            parent: emptyParent,
+        });
+    }
+    else if (ctxRef.set) {
+        return vestUtils.assign(base, {
+            parent: () => stripContext(parentContext),
+        });
+    }
+    return parentContext;
+});
+function stripContext(ctx) {
+    if (!ctx) {
+        return null;
+    }
+    return {
+        value: ctx.value,
+        meta: ctx.meta,
+        parent: ctx.parent,
+    };
+}
+function emptyParent() {
+    return null;
+}
+
 function endsWith(value, arg1) {
     return vestUtils.isStringValue(value) && vestUtils.isStringValue(arg1) && value.endsWith(arg1);
 }
-var doesNotEndWith = vestUtils.bindNot(endsWith);
+const doesNotEndWith = vestUtils.bindNot(endsWith);
 
 function equals(value, arg1) {
     return value === arg1;
 }
-var notEquals = vestUtils.bindNot(equals);
+const notEquals = vestUtils.bindNot(equals);
 
 function greaterThanOrEquals(value, gte) {
     return vestUtils.numberEquals(value, gte) || vestUtils.greaterThan(value, gte);
@@ -29,7 +60,7 @@ function inside(value, arg1) {
     }
     return false;
 }
-var notInside = vestUtils.bindNot(inside);
+const notInside = vestUtils.bindNot(inside);
 
 function lessThan(value, lt) {
     return vestUtils.isNumeric(value) && vestUtils.isNumeric(lt) && Number(value) < Number(lt);
@@ -42,19 +73,19 @@ function lessThanOrEquals(value, lte) {
 function isBetween(value, min, max) {
     return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
 }
-var isNotBetween = vestUtils.bindNot(isBetween);
+const isNotBetween = vestUtils.bindNot(isBetween);
 
 function isBlank(value) {
     return vestUtils.isNullish(value) || (vestUtils.isStringValue(value) && !value.trim());
 }
-var isNotBlank = vestUtils.bindNot(isBlank);
+const isNotBlank = vestUtils.bindNot(isBlank);
 
-var isNotBoolean = vestUtils.bindNot(vestUtils.isBoolean);
+const isNotBoolean = vestUtils.bindNot(vestUtils.isBoolean);
 
 /**
  * Validates that a given value is an even number
  */
-var isEven = function (value) {
+const isEven = (value) => {
     if (vestUtils.isNumeric(value)) {
         return value % 2 === 0;
     }
@@ -64,12 +95,12 @@ var isEven = function (value) {
 function isKeyOf(key, obj) {
     return key in obj;
 }
-var isNotKeyOf = vestUtils.bindNot(isKeyOf);
+const isNotKeyOf = vestUtils.bindNot(isKeyOf);
 
 function isNaN(value) {
     return Number.isNaN(value);
 }
-var isNotNaN = vestUtils.bindNot(isNaN);
+const isNotNaN = vestUtils.bindNot(isNaN);
 
 function isNegative(value) {
     return lessThan(value, 0);
@@ -78,37 +109,37 @@ function isNegative(value) {
 function isNumber(value) {
     return Boolean(typeof value === 'number');
 }
-var isNotNumber = vestUtils.bindNot(isNumber);
+const isNotNumber = vestUtils.bindNot(isNumber);
 
 /**
  * Validates that a given value is an odd number
  */
-var isOdd = function (value) {
+const isOdd = (value) => {
     if (vestUtils.isNumeric(value)) {
         return value % 2 !== 0;
     }
     return false;
 };
 
-var isNotString = vestUtils.bindNot(vestUtils.isStringValue);
+const isNotString = vestUtils.bindNot(vestUtils.isStringValue);
 
 function isTruthy(value) {
     return !!value;
 }
-var isFalsy = vestUtils.bindNot(isTruthy);
+const isFalsy = vestUtils.bindNot(isTruthy);
 
 function isValueOf(value, objectToCheck) {
     if (vestUtils.isNullish(objectToCheck)) {
         return false;
     }
-    for (var key in objectToCheck) {
+    for (const key in objectToCheck) {
         if (objectToCheck[key] === value) {
             return true;
         }
     }
     return false;
 }
-var isNotValueOf = vestUtils.bindNot(isValueOf);
+const isNotValueOf = vestUtils.bindNot(isValueOf);
 
 function longerThanOrEquals(value, arg1) {
     return greaterThanOrEquals(value.length, arg1);
@@ -121,11 +152,9 @@ function matches(value, regex) {
     else if (vestUtils.isStringValue(regex)) {
         return new RegExp(regex).test(value);
     }
-    else {
-        return false;
-    }
+    return false;
 }
-var notMatches = vestUtils.bindNot(matches);
+const notMatches = vestUtils.bindNot(matches);
 
 function condition(value, callback) {
     try {
@@ -147,156 +176,82 @@ function shorterThanOrEquals(value, arg1) {
 function startsWith(value, arg1) {
     return vestUtils.isStringValue(value) && vestUtils.isStringValue(arg1) && value.startsWith(arg1);
 }
-var doesNotStartWith = vestUtils.bindNot(startsWith);
+const doesNotStartWith = vestUtils.bindNot(startsWith);
 
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, max-lines-per-function
 function rules() {
     return {
-        condition: condition,
-        doesNotEndWith: doesNotEndWith,
-        doesNotStartWith: doesNotStartWith,
-        endsWith: endsWith,
-        equals: equals,
+        condition,
+        doesNotEndWith,
+        doesNotStartWith,
+        endsWith,
+        equals,
         greaterThan: vestUtils.greaterThan,
-        greaterThanOrEquals: greaterThanOrEquals,
+        greaterThanOrEquals,
         gt: vestUtils.greaterThan,
         gte: greaterThanOrEquals,
-        inside: inside,
+        inside,
         isArray: vestUtils.isArray,
-        isBetween: isBetween,
-        isBlank: isBlank,
+        isBetween,
+        isBlank,
         isBoolean: vestUtils.isBoolean,
         isEmpty: vestUtils.isEmpty,
-        isEven: isEven,
-        isFalsy: isFalsy,
-        isKeyOf: isKeyOf,
-        isNaN: isNaN,
-        isNegative: isNegative,
+        isEven,
+        isFalsy,
+        isKeyOf,
+        isNaN,
+        isNegative,
         isNotArray: vestUtils.isNotArray,
-        isNotBetween: isNotBetween,
-        isNotBlank: isNotBlank,
-        isNotBoolean: isNotBoolean,
+        isNotBetween,
+        isNotBlank,
+        isNotBoolean,
         isNotEmpty: vestUtils.isNotEmpty,
-        isNotKeyOf: isNotKeyOf,
-        isNotNaN: isNotNaN,
+        isNotKeyOf,
+        isNotNaN,
         isNotNull: vestUtils.isNotNull,
         isNotNullish: vestUtils.isNotNullish,
-        isNotNumber: isNotNumber,
+        isNotNumber,
         isNotNumeric: vestUtils.isNotNumeric,
-        isNotString: isNotString,
+        isNotString,
         isNotUndefined: vestUtils.isNotUndefined,
-        isNotValueOf: isNotValueOf,
+        isNotValueOf,
         isNull: vestUtils.isNull,
         isNullish: vestUtils.isNullish,
-        isNumber: isNumber,
+        isNumber,
         isNumeric: vestUtils.isNumeric,
-        isOdd: isOdd,
+        isOdd,
         isPositive: vestUtils.isPositive,
         isString: vestUtils.isStringValue,
-        isTruthy: isTruthy,
+        isTruthy,
         isUndefined: vestUtils.isUndefined,
-        isValueOf: isValueOf,
+        isValueOf,
         lengthEquals: vestUtils.lengthEquals,
         lengthNotEquals: vestUtils.lengthNotEquals,
-        lessThan: lessThan,
-        lessThanOrEquals: lessThanOrEquals,
+        lessThan,
+        lessThanOrEquals,
         longerThan: vestUtils.longerThan,
-        longerThanOrEquals: longerThanOrEquals,
+        longerThanOrEquals,
         lt: lessThan,
         lte: lessThanOrEquals,
-        matches: matches,
-        notEquals: notEquals,
-        notInside: notInside,
-        notMatches: notMatches,
+        matches,
+        notEquals,
+        notInside,
+        notMatches,
         numberEquals: vestUtils.numberEquals,
         numberNotEquals: vestUtils.numberNotEquals,
-        shorterThan: shorterThan,
-        shorterThanOrEquals: shorterThanOrEquals,
-        startsWith: startsWith
+        shorterThan,
+        shorterThanOrEquals,
+        startsWith,
     };
 }
 
-var baseRules = rules();
+const baseRules = rules();
 function getRule(ruleName) {
     return baseRules[ruleName];
 }
 
-function eachEnforceRule(action) {
-    for (var ruleName in baseRules) {
-        var ruleFn = getRule(ruleName);
-        if (vestUtils.isFunction(ruleFn)) {
-            action(ruleName, ruleFn);
-        }
-    }
-}
-
-var ctx = context.createCascade(function (ctxRef, parentContext) {
-    var base = {
-        value: ctxRef.value,
-        meta: ctxRef.meta || {}
-    };
-    if (!parentContext) {
-        return vestUtils.assign(base, {
-            parent: emptyParent
-        });
-    }
-    else if (ctxRef.set) {
-        return vestUtils.assign(base, {
-            parent: function () { return stripContext(parentContext); }
-        });
-    }
-    return parentContext;
-});
-function stripContext(ctx) {
-    if (!ctx) {
-        return ctx;
-    }
-    return {
-        value: ctx.value,
-        meta: ctx.meta,
-        parent: ctx.parent
-    };
-}
-function emptyParent() {
-    return null;
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-function isProxySupported() {
-    try {
-        return vestUtils.isFunction(Proxy);
-    }
-    catch (_a) {
-        return false;
-    }
-}
-
 function ruleReturn(pass, message) {
-    var output = { pass: pass };
+    const output = { pass };
     if (message) {
         output.message = message;
     }
@@ -312,124 +267,106 @@ function defaultToPassing(callback) {
 /**
  * Transform the result of a rule into a standard format
  */
-function transformResult(result, ruleName, value) {
-    var args = [];
-    for (var _i = 3; _i < arguments.length; _i++) {
-        args[_i - 3] = arguments[_i];
-    }
+function transformResult(result, ruleName, value, ...args) {
     validateResult(result);
     // if result is boolean
     if (vestUtils.isBoolean(result)) {
         return ruleReturn(result);
     }
-    else {
-        return ruleReturn(result.pass, vestUtils.optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args, false)));
-    }
+    return ruleReturn(result.pass, vestUtils.optionalFunctionValue(result.message, ruleName, value, ...args));
 }
 function validateResult(result) {
     // if result is boolean, or if result.pass is boolean
     vestUtils.invariant(vestUtils.isBoolean(result) || (result && vestUtils.isBoolean(result.pass)), 'Incorrect return value for rule: ' + JSON.stringify(result));
 }
 
+// eslint-disable-next-line max-lines-per-function
 function enforceEager(value) {
-    var target = {};
-    // This condition is for when we don't have proxy support (ES5).
-    // In this case, we need to manually assign the rules to the target object on runtime.
-    // The follow up proxy block is used in case we do have proxy support, and we can assign each rule upon invocation.
-    if (!isProxySupported()) {
-        // We iterate over each of the rules, and add them to the target object being return by enforce
-        eachEnforceRule(function (ruleName, ruleFn) {
-            // We then wrap the rule with `genRuleCall` that adds the base enforce behavior
-            target[ruleName] = genRuleCall(target, ruleFn, ruleName);
-        });
-        return target;
-    }
+    const target = {
+        message,
+    };
+    let customMessage = undefined;
     // We create a proxy intercepting access to the target object (which is empty).
-    var proxy = new Proxy(target, {
-        get: function (_, ruleName) {
+    const proxy = new Proxy(target, {
+        get: (_, key) => {
             // On property access, we identify if it is a rule or not.
-            var rule = getRule(ruleName);
+            const rule = getRule(key);
             // If it is a rule, we wrap it with `genRuleCall` that adds the base enforce behavior
             if (rule) {
-                return genRuleCall(proxy, rule, ruleName);
+                return genRuleCall(proxy, rule, key);
             }
-        }
+            return target[key];
+        },
     });
     return proxy;
     // This function is used to wrap a rule with the base enforce behavior
     // It takes the target object, the rule function, and the rule name
     // It then returns the rule, in a manner that can be used by enforce
     function genRuleCall(target, rule, ruleName) {
-        return function ruleCall() {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
+        return function ruleCall(...args) {
             // Order of operation:
             // 1. Create a context with the value being enforced
             // 2. Call the rule within the context, and pass over the arguments passed to it
             // 3. Transform the result to the correct output format
-            var transformedResult = ctx.run({ value: value }, function () {
-                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
+            const transformedResult = ctx.run({ value }, () => {
+                return transformResult(rule(value, ...args), ruleName, value, ...args);
             });
+            function enforceMessage() {
+                if (!vestUtils.isNullish(customMessage))
+                    return vestUtils.StringObject(customMessage);
+                if (vestUtils.isNullish(transformedResult.message)) {
+                    return `enforce/${ruleName} failed with ${JSON.stringify(value)}`;
+                }
+                return vestUtils.StringObject(transformedResult.message);
+            }
             // On rule failure (the result is false), we either throw an error
             // or throw a string value if the rule has a message defined in it.
-            vestUtils.invariant(transformedResult.pass, vestUtils.isNullish(transformedResult.message)
-                ? "enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value))
-                : vestUtils.StringObject(transformedResult.message));
+            vestUtils.invariant(transformedResult.pass, enforceMessage());
             return target;
         };
     }
+    function message(input) {
+        customMessage = input;
+        return proxy;
+    }
 }
 
 // eslint-disable-next-line max-lines-per-function
 function genEnforceLazy(key) {
-    var registeredRules = [];
-    var lazyMessage;
+    const registeredRules = [];
+    let lazyMessage;
     return addLazyRule(key);
     // eslint-disable-next-line max-lines-per-function
     function addLazyRule(ruleName) {
         // eslint-disable-next-line max-lines-per-function
-        return function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var rule = getRule(ruleName);
-            registeredRules.push(function (value) {
-                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
-            });
-            var proxy = {
-                run: function (value) {
-                    return defaultToPassing(vestUtils.mapFirst(registeredRules, function (rule, breakout) {
+        return (...args) => {
+            const rule = getRule(ruleName);
+            registeredRules.push((value) => transformResult(rule(value, ...args), ruleName, value, ...args));
+            let proxy = {
+                run: (value) => {
+                    return defaultToPassing(vestUtils.mapFirst(registeredRules, (rule, breakout) => {
                         var _a;
-                        var res = ctx.run({ value: value }, function () { return rule(value); });
+                        const res = ctx.run({ value }, () => rule(value));
                         breakout(!res.pass, ruleReturn(!!res.pass, (_a = vestUtils.optionalFunctionValue(lazyMessage, value, res.message)) !== null && _a !== void 0 ? _a : res.message));
                     }));
                 },
-                test: function (value) { return proxy.run(value).pass; },
-                message: function (message) {
+                test: (value) => proxy.run(value).pass,
+                message: (message) => {
                     if (message) {
                         lazyMessage = message;
                     }
                     return proxy;
-                }
+                },
             };
-            if (!isProxySupported()) {
-                eachEnforceRule(function (ruleName) {
-                    proxy[ruleName] = addLazyRule(ruleName);
-                });
-                return proxy;
-            }
             // reassigning the proxy here is not pretty
             // but it's a cleaner way of getting `run` and `test` for free
             proxy = new Proxy(proxy, {
-                get: function (target, key) {
+                get: (target, key) => {
                     if (getRule(key)) {
                         return addLazyRule(key);
                     }
                     return target[key]; // already has `run` and `test` on it
-                }
+                },
             });
             return proxy;
         };
@@ -463,16 +400,14 @@ function genEnforceLazy(key) {
  * while run will return an object with the validation result and an optional message created by the rule.
  */
 function genEnforce() {
-    var target = {
-        context: function () { return ctx.useX(); },
-        extend: function (customRules) {
+    const target = {
+        context: () => ctx.useX(),
+        extend: (customRules) => {
             vestUtils.assign(baseRules, customRules);
-            handleNoProxy(); // TODO: REMOVE when we stop supporting ES5
-        }
+        },
     };
-    handleNoProxy();
     return new Proxy(vestUtils.assign(enforceEager, target), {
-        get: function (target, key) {
+        get: (target, key) => {
             if (key in target) {
                 return target[key];
             }
@@ -481,19 +416,10 @@ function genEnforce() {
             }
             // Only on the first rule access - start the chain of calls
             return genEnforceLazy(key);
-        }
+        },
     });
-    function handleNoProxy() {
-        if (!isProxySupported()) {
-            eachEnforceRule(function (ruleName) {
-                // Only on the first rule access - start the chain of calls
-                target[ruleName] = genEnforceLazy(ruleName);
-            });
-            return vestUtils.assign(enforceEager, target);
-        }
-    }
 }
-var enforce = genEnforce();
+const enforce = genEnforce();
 
 exports.ctx = ctx;
 exports.enforce = enforce;

package/dist/cjs/n4s.production.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var n=require("vest-utils"),t=require("context");function r(t,r){return n.isStringValue(t)&&n.isStringValue(r)&&t.endsWith(r)}var i=n.bindNot(r);function e(n,t){return n===t}var u=n.bindNot(e);function s(t,r){return n.numberEquals(t,r)||n.greaterThan(t,r)}function o(t,r){return!!(n.isArray(r)||n.isStringValue(r)&&n.isStringValue(t))&&-1!==r.indexOf(t)}var a=n.bindNot(o);function l(t,r){return n.isNumeric(t)&&n.isNumeric(r)&&Number(t)<Number(r)}function c(t,r){return n.numberEquals(t,r)||l(t,r)}function f(n,t,r){return s(n,t)&&c(n,r)}var N=n.bindNot(f);function g(t){return n.isNullish(t)||n.isStringValue(t)&&!t.trim()}var v=n.bindNot(g),d=n.bindNot(n.isBoolean),h=function(t){return!!n.isNumeric(t)&&0==t%2};function p(n,t){return n in t}var m=n.bindNot(p);function y(n){return Number.isNaN(n)}var b=n.bindNot(y);function E(n){return l(n,0)}function q(n){return"number"==typeof n}var S=n.bindNot(q),x=function(t){return!!n.isNumeric(t)&&0!=t%2},O=n.bindNot(n.isStringValue);function T(n){return!!n}var V=n.bindNot(T);function B(t,r){if(n.isNullish(r))return!1;for(var i in r)if(r[i]===t)return!0;return!1}var w=n.bindNot(B);function A(n,t){return s(n.length,t)}function P(t,r){return r instanceof RegExp?r.test(t):!!n.isStringValue(r)&&new RegExp(r).test(t)}var F=n.bindNot(P);function W(n,t){try{return t(n)}catch(n){return!1}}function U(n,t){return l(n.length,t)}function j(n,t){return c(n.length,t)}function k(t,r){return n.isStringValue(t)&&n.isStringValue(r)&&t.startsWith(r)}var I=n.bindNot(k);var J={condition:W,doesNotEndWith:i,doesNotStartWith:I,endsWith:r,equals:e,greaterThan:n.greaterThan,greaterThanOrEquals:s,gt:n.greaterThan,gte:s,inside:o,isArray:n.isArray,isBetween:f,isBlank:g,isBoolean:n.isBoolean,isEmpty:n.isEmpty,isEven:h,isFalsy:V,isKeyOf:p,isNaN:y,isNegative:E,isNotArray:n.isNotArray,isNotBetween:N,isNotBlank:v,isNotBoolean:d,isNotEmpty:n.isNotEmpty,isNotKeyOf:m,isNotNaN:b,isNotNull:n.isNotNull,isNotNullish:n.isNotNullish,isNotNumber:S,isNotNumeric:n.isNotNumeric,isNotString:O,isNotUndefined:n.isNotUndefined,isNotValueOf:w,isNull:n.isNull,isNullish:n.isNullish,isNumber:q,isNumeric:n.isNumeric,isOdd:x,isPositive:n.isPositive,isString:n.isStringValue,isTruthy:T,isUndefined:n.isUndefined,isValueOf:B,lengthEquals:n.lengthEquals,lengthNotEquals:n.lengthNotEquals,lessThan:l,lessThanOrEquals:c,longerThan:n.longerThan,longerThanOrEquals:A,lt:l,lte:c,matches:P,notEquals:u,notInside:a,notMatches:F,numberEquals:n.numberEquals,numberNotEquals:n.numberNotEquals,shorterThan:U,shorterThanOrEquals:j,startsWith:k};function K(n){return J[n]}function M(t){for(var r in J){var i=K(r);n.isFunction(i)&&t(r,i)}}var R=t.createCascade((function(t,r){var i={value:t.value,meta:t.meta||{}};return r?t.set?n.assign(i,{parent:function(){return function(n){return n?{value:n.value,meta:n.meta,parent:n.parent}:n}(r)}}):r:n.assign(i,{parent:_})}));function _(){return null}function C(n,t,r){if(r||2===arguments.length)for(var i,e=0,u=t.length;e<u;e++)!i&&e in t||(i||(i=Array.prototype.slice.call(t,0,e)),i[e]=t[e]);return n.concat(i||Array.prototype.slice.call(t))}function X(){try{return n.isFunction(Proxy)}catch(n){return!1}}function z(n,t){return n={pass:n},t&&(n.message=t),n}function D(t){return n.defaultTo(t,z(!0))}function G(t,r,i){for(var e=[],u=3;u<arguments.length;u++)e[u-3]=arguments[u];return H(t),n.isBoolean(t)?z(t):z(t.pass,n.optionalFunctionValue.apply(void 0,C([t.message,r,i],e,!1)))}function H(t){n.invariant(n.isBoolean(t)||t&&n.isBoolean(t.pass),"Incorrect return value for rule: "+JSON.stringify(t))}function L(t){function r(r,i,e){return function(){for(var u=[],s=0;s<arguments.length;s++)u[s]=arguments[s];return s=R.run({value:t},(function(){return G.apply(void 0,C([i.apply(void 0,C([t],u,!1)),e,t],u,!1))})),n.invariant(s.pass,n.isNullish(s.message)?"enforce/".concat(e," failed with ").concat(JSON.stringify(t)):n.StringObject(s.message)),r}}var i={};if(!X())return M((function(n,t){i[n]=r(i,t,n)})),i;var e=new Proxy(i,{get:function(n,t){if(n=K(t))return r(e,n,t)}});return e}function Q(t){var r,i=[];return function t(e){return function(){for(var u=[],s=0;s<arguments.length;s++)u[s]=arguments[s];var o=K(e);i.push((function(n){return G.apply(void 0,C([o.apply(void 0,C([n],u,!1)),e,n],u,!1))}));var a={run:function(t){return D(n.mapFirst(i,(function(i,e){var u,s=R.run({value:t},(function(){return i(t)}));e(!s.pass,z(!!s.pass,null!==(u=n.optionalFunctionValue(r,t,s.message))&&void 0!==u?u:s.message))})))},test:function(n){return a.run(n).pass},message:function(n){return n&&(r=n),a}};return X()?a=new Proxy(a,{get:function(n,r){return K(r)?t(r):n[r]}}):(M((function(n){a[n]=t(n)})),a)}}(t)}var Y=function(){function t(){if(!X())return M((function(n){r[n]=Q(n)})),n.assign(L,r)}var r={context:function(){return R.useX()},extend:function(r){n.assign(J,r),t()}};return t(),new Proxy(n.assign(L,r),{get:function(n,t){return t in n?n[t]:K(t)?Q(t):void 0}})}();exports.ctx=R,exports.enforce=Y;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var n=require("vest-utils");const t=require("context").createCascade(((t,i)=>{const s={value:t.value,meta:t.meta||{}};return i?t.set?n.assign(s,{parent:()=>function(n){if(!n)return null;return{value:n.value,meta:n.meta,parent:n.parent}}(i)}):i:n.assign(s,{parent:e})}));function e(){return null}function i(t,e){return n.isStringValue(t)&&n.isStringValue(e)&&t.endsWith(e)}const s=n.bindNot(i);function r(n,t){return n===t}const u=n.bindNot(r);function o(t,e){return n.numberEquals(t,e)||n.greaterThan(t,e)}function a(t,e){return(n.isArray(e)||!(!n.isStringValue(e)||!n.isStringValue(t)))&&-1!==e.indexOf(t)}const l=n.bindNot(a);function c(t,e){return n.isNumeric(t)&&n.isNumeric(e)&&Number(t)<Number(e)}function N(t,e){return n.numberEquals(t,e)||c(t,e)}function f(n,t,e){return o(n,t)&&N(n,e)}const g=n.bindNot(f);function d(t){return n.isNullish(t)||n.isStringValue(t)&&!t.trim()}const h=n.bindNot(d),m=n.bindNot(n.isBoolean),b=t=>!!n.isNumeric(t)&&t%2==0;function p(n,t){return n in t}const E=n.bindNot(p);function y(n){return Number.isNaN(n)}const v=n.bindNot(y);function q(n){return c(n,0)}function S(n){return Boolean("number"==typeof n)}const O=n.bindNot(S),T=t=>!!n.isNumeric(t)&&t%2!=0,V=n.bindNot(n.isStringValue);function x(n){return!!n}const B=n.bindNot(x);function w(t,e){if(n.isNullish(e))return!1;for(const n in e)if(e[n]===t)return!0;return!1}const P=n.bindNot(w);function W(n,t){return o(n.length,t)}function A(t,e){return e instanceof RegExp?e.test(t):!!n.isStringValue(e)&&new RegExp(e).test(t)}const F=n.bindNot(A);function U(n,t){try{return t(n)}catch(n){return!1}}function j(n,t){return c(n.length,t)}function k(n,t){return N(n.length,t)}function I(t,e){return n.isStringValue(t)&&n.isStringValue(e)&&t.startsWith(e)}const J=n.bindNot(I);const K={condition:U,doesNotEndWith:s,doesNotStartWith:J,endsWith:i,equals:r,greaterThan:n.greaterThan,greaterThanOrEquals:o,gt:n.greaterThan,gte:o,inside:a,isArray:n.isArray,isBetween:f,isBlank:d,isBoolean:n.isBoolean,isEmpty:n.isEmpty,isEven:b,isFalsy:B,isKeyOf:p,isNaN:y,isNegative:q,isNotArray:n.isNotArray,isNotBetween:g,isNotBlank:h,isNotBoolean:m,isNotEmpty:n.isNotEmpty,isNotKeyOf:E,isNotNaN:v,isNotNull:n.isNotNull,isNotNullish:n.isNotNullish,isNotNumber:O,isNotNumeric:n.isNotNumeric,isNotString:V,isNotUndefined:n.isNotUndefined,isNotValueOf:P,isNull:n.isNull,isNullish:n.isNullish,isNumber:S,isNumeric:n.isNumeric,isOdd:T,isPositive:n.isPositive,isString:n.isStringValue,isTruthy:x,isUndefined:n.isUndefined,isValueOf:w,lengthEquals:n.lengthEquals,lengthNotEquals:n.lengthNotEquals,lessThan:c,lessThanOrEquals:N,longerThan:n.longerThan,longerThanOrEquals:W,lt:c,lte:N,matches:A,notEquals:u,notInside:l,notMatches:F,numberEquals:n.numberEquals,numberNotEquals:n.numberNotEquals,shorterThan:j,shorterThanOrEquals:k,startsWith:I};function M(n){return K[n]}function R(n,t){const e={pass:n};return t&&(e.message=t),e}function $(t){return n.defaultTo(t,R(!0))}function _(t,e,i,...s){return function(t){n.invariant(n.isBoolean(t)||t&&n.isBoolean(t.pass),"Incorrect return value for rule: "+JSON.stringify(t))}(t),n.isBoolean(t)?R(t):R(t.pass,n.optionalFunctionValue(t.message,e,i,...s))}function C(e){const i={message:function(n){return s=n,r}};let s;const r=new Proxy(i,{get:(u,o)=>{const a=M(o);return a?function(i,r,u){return function(...o){const a=t.run({value:e},(()=>_(r(e,...o),u,e,...o)));function l(){return n.isNullish(s)?n.isNullish(a.message)?`enforce/${u} failed with ${JSON.stringify(e)}`:n.StringObject(a.message):n.StringObject(s)}return n.invariant(a.pass,l()),i}}(r,a,o):i[o]}});return r}const X=function(){const e={context:()=>t.useX(),extend:t=>{n.assign(K,t)}};return new Proxy(n.assign(C,e),{get:(e,i)=>i in e?e[i]:M(i)?function(e){const i=[];let s;return function e(r){return(...u)=>{const o=M(r);i.push((n=>_(o(n,...u),r,n,...u)));let a={run:e=>$(n.mapFirst(i,((i,r)=>{var u;const o=t.run({value:e},(()=>i(e)));r(!o.pass,R(!!o.pass,null!==(u=n.optionalFunctionValue(s,e,o.message))&&void 0!==u?u:o.message))}))),test:n=>a.run(n).pass,message:n=>(n&&(s=n),a)};return a=new Proxy(a,{get:(n,t)=>M(t)?e(t):n[t]}),a}}(e)}(i):void 0})}();exports.ctx=t,exports.enforce=X;

package/dist/cjs/schema.development.js

@@ -6,7 +6,7 @@ var n4s = require('n4s');
 var vestUtils = require('vest-utils');
 
 function ruleReturn(pass, message) {
-    var output = { pass: pass };
+    const output = { pass };
     if (message) {
         output.message = message;
     }
@@ -32,27 +32,20 @@ function runLazyRule(lazyRule, currentValue) {
 }
 
 function isArrayOf(inputArray, currentRule) {
-    return defaultToPassing(vestUtils.mapFirst(inputArray, function (currentValue, breakout, index) {
-        var res = n4s.ctx.run({ value: currentValue, set: true, meta: { index: index } }, function () { return runLazyRule(currentRule, currentValue); });
+    return defaultToPassing(vestUtils.mapFirst(inputArray, (currentValue, breakout, index) => {
+        const res = n4s.ctx.run({ value: currentValue, set: true, meta: { index } }, () => runLazyRule(currentRule, currentValue));
         breakout(!res.pass, res);
     }));
 }
 
 function loose(inputObject, shapeObject) {
-    var _loop_1 = function (key) {
-        var currentValue = inputObject[key];
-        var currentRule = shapeObject[key];
-        var res = n4s.ctx.run({ value: currentValue, set: true, meta: { key: key } }, function () {
-            return runLazyRule(currentRule, currentValue);
-        });
+    for (const key in shapeObject) {
+        const currentValue = inputObject[key];
+        const currentRule = shapeObject[key];
+        const res = n4s.ctx.run({ value: currentValue, set: true, meta: { key } }, () => runLazyRule(currentRule, currentValue));
         if (!res.pass) {
-            return { value: res };
+            return res;
         }
-    };
-    for (var key in shapeObject) {
-        var state_1 = _loop_1(key);
-        if (typeof state_1 === "object")
-            return state_1.value;
     }
     return passing();
 }
@@ -65,11 +58,11 @@ function optional(value, ruleChain) {
 }
 
 function shape(inputObject, shapeObject) {
-    var baseRes = loose(inputObject, shapeObject);
+    const baseRes = loose(inputObject, shapeObject);
     if (!baseRes.pass) {
         return baseRes;
     }
-    for (var key in inputObject) {
+    for (const key in inputObject) {
         if (!vestUtils.hasOwnProperty(shapeObject, key)) {
             return failing();
         }
@@ -80,13 +73,13 @@ function shape(inputObject, shapeObject) {
 // Help needed improving the typings of this file.
 // Ideally, we'd be able to extend ShapeObject, but that's not possible.
 function partial(shapeObject) {
-    var output = {};
-    for (var key in shapeObject) {
+    const output = {};
+    for (const key in shapeObject) {
         output[key] = n4s.enforce.optional(shapeObject[key]);
     }
     return output;
 }
 
-n4s.enforce.extend({ isArrayOf: isArrayOf, loose: loose, optional: optional, shape: shape });
+n4s.enforce.extend({ isArrayOf, loose, optional, shape });
 
 exports.partial = partial;