n4s 4.3.6 → 4.3.8-dev-9c596e

package/dist/es/n4s.development.js

@@ -4,12 +4,12 @@ import { createCascade } from 'context';
 function endsWith(value, arg1) {
     return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
 }
-var doesNotEndWith = bindNot(endsWith);
+const doesNotEndWith = bindNot(endsWith);
 
 function equals(value, arg1) {
     return value === arg1;
 }
-var notEquals = bindNot(equals);
+const notEquals = bindNot(equals);
 
 function greaterThanOrEquals(value, gte) {
     return numberEquals(value, gte) || greaterThan(value, gte);
@@ -25,7 +25,7 @@ function inside(value, arg1) {
     }
     return false;
 }
-var notInside = bindNot(inside);
+const notInside = bindNot(inside);
 
 function lessThan(value, lt) {
     return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
@@ -38,19 +38,19 @@ function lessThanOrEquals(value, lte) {
 function isBetween(value, min, max) {
     return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
 }
-var isNotBetween = bindNot(isBetween);
+const isNotBetween = bindNot(isBetween);
 
 function isBlank(value) {
     return isNullish(value) || (isStringValue(value) && !value.trim());
 }
-var isNotBlank = bindNot(isBlank);
+const isNotBlank = bindNot(isBlank);
 
-var isNotBoolean = bindNot(isBoolean);
+const isNotBoolean = bindNot(isBoolean);
 
 /**
  * Validates that a given value is an even number
  */
-var isEven = function (value) {
+const isEven = (value) => {
     if (isNumeric(value)) {
         return value % 2 === 0;
     }
@@ -60,12 +60,12 @@ var isEven = function (value) {
 function isKeyOf(key, obj) {
     return key in obj;
 }
-var isNotKeyOf = bindNot(isKeyOf);
+const isNotKeyOf = bindNot(isKeyOf);
 
 function isNaN(value) {
     return Number.isNaN(value);
 }
-var isNotNaN = bindNot(isNaN);
+const isNotNaN = bindNot(isNaN);
 
 function isNegative(value) {
     return lessThan(value, 0);
@@ -74,37 +74,37 @@ function isNegative(value) {
 function isNumber(value) {
     return Boolean(typeof value === 'number');
 }
-var isNotNumber = bindNot(isNumber);
+const isNotNumber = bindNot(isNumber);
 
 /**
  * Validates that a given value is an odd number
  */
-var isOdd = function (value) {
+const isOdd = (value) => {
     if (isNumeric(value)) {
         return value % 2 !== 0;
     }
     return false;
 };
 
-var isNotString = bindNot(isStringValue);
+const isNotString = bindNot(isStringValue);
 
 function isTruthy(value) {
     return !!value;
 }
-var isFalsy = bindNot(isTruthy);
+const isFalsy = bindNot(isTruthy);
 
 function isValueOf(value, objectToCheck) {
     if (isNullish(objectToCheck)) {
         return false;
     }
-    for (var key in objectToCheck) {
+    for (const key in objectToCheck) {
         if (objectToCheck[key] === value) {
             return true;
         }
     }
     return false;
 }
-var isNotValueOf = bindNot(isValueOf);
+const isNotValueOf = bindNot(isValueOf);
 
 function longerThanOrEquals(value, arg1) {
     return greaterThanOrEquals(value.length, arg1);
@@ -119,7 +119,7 @@ function matches(value, regex) {
     }
     return false;
 }
-var notMatches = bindNot(matches);
+const notMatches = bindNot(matches);
 
 function condition(value, callback) {
     try {
@@ -141,102 +141,102 @@ function shorterThanOrEquals(value, arg1) {
 function startsWith(value, arg1) {
     return isStringValue(value) && isStringValue(arg1) && value.startsWith(arg1);
 }
-var doesNotStartWith = bindNot(startsWith);
+const doesNotStartWith = 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,
-        greaterThan: greaterThan,
-        greaterThanOrEquals: greaterThanOrEquals,
+        condition,
+        doesNotEndWith,
+        doesNotStartWith,
+        endsWith,
+        equals,
+        greaterThan,
+        greaterThanOrEquals,
         gt: greaterThan,
         gte: greaterThanOrEquals,
-        inside: inside,
-        isArray: isArray,
-        isBetween: isBetween,
-        isBlank: isBlank,
-        isBoolean: isBoolean,
-        isEmpty: isEmpty,
-        isEven: isEven,
-        isFalsy: isFalsy,
-        isKeyOf: isKeyOf,
-        isNaN: isNaN,
-        isNegative: isNegative,
-        isNotArray: isNotArray,
-        isNotBetween: isNotBetween,
-        isNotBlank: isNotBlank,
-        isNotBoolean: isNotBoolean,
-        isNotEmpty: isNotEmpty,
-        isNotKeyOf: isNotKeyOf,
-        isNotNaN: isNotNaN,
-        isNotNull: isNotNull,
-        isNotNullish: isNotNullish,
-        isNotNumber: isNotNumber,
-        isNotNumeric: isNotNumeric,
-        isNotString: isNotString,
-        isNotUndefined: isNotUndefined,
-        isNotValueOf: isNotValueOf,
-        isNull: isNull,
-        isNullish: isNullish,
-        isNumber: isNumber,
-        isNumeric: isNumeric,
-        isOdd: isOdd,
-        isPositive: isPositive,
+        inside,
+        isArray,
+        isBetween,
+        isBlank,
+        isBoolean,
+        isEmpty,
+        isEven,
+        isFalsy,
+        isKeyOf,
+        isNaN,
+        isNegative,
+        isNotArray,
+        isNotBetween,
+        isNotBlank,
+        isNotBoolean,
+        isNotEmpty,
+        isNotKeyOf,
+        isNotNaN,
+        isNotNull,
+        isNotNullish,
+        isNotNumber,
+        isNotNumeric,
+        isNotString,
+        isNotUndefined,
+        isNotValueOf,
+        isNull,
+        isNullish,
+        isNumber,
+        isNumeric,
+        isOdd,
+        isPositive,
         isString: isStringValue,
-        isTruthy: isTruthy,
-        isUndefined: isUndefined,
-        isValueOf: isValueOf,
-        lengthEquals: lengthEquals,
-        lengthNotEquals: lengthNotEquals,
-        lessThan: lessThan,
-        lessThanOrEquals: lessThanOrEquals,
-        longerThan: longerThan,
-        longerThanOrEquals: longerThanOrEquals,
+        isTruthy,
+        isUndefined,
+        isValueOf,
+        lengthEquals,
+        lengthNotEquals,
+        lessThan,
+        lessThanOrEquals,
+        longerThan,
+        longerThanOrEquals,
         lt: lessThan,
         lte: lessThanOrEquals,
-        matches: matches,
-        notEquals: notEquals,
-        notInside: notInside,
-        notMatches: notMatches,
-        numberEquals: numberEquals,
-        numberNotEquals: numberNotEquals,
-        shorterThan: shorterThan,
-        shorterThanOrEquals: shorterThanOrEquals,
-        startsWith: startsWith
+        matches,
+        notEquals,
+        notInside,
+        notMatches,
+        numberEquals,
+        numberNotEquals,
+        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);
+    for (const ruleName in baseRules) {
+        const ruleFn = getRule(ruleName);
         if (isFunction(ruleFn)) {
             action(ruleName, ruleFn);
         }
     }
 }
 
-var ctx = createCascade(function (ctxRef, parentContext) {
-    var base = {
+const ctx = createCascade((ctxRef, parentContext) => {
+    const base = {
         value: ctxRef.value,
-        meta: ctxRef.meta || {}
+        meta: ctxRef.meta || {},
     };
     if (!parentContext) {
         return assign(base, {
-            parent: emptyParent
+            parent: emptyParent,
         });
     }
     else if (ctxRef.set) {
         return assign(base, {
-            parent: function () { return stripContext(parentContext); }
+            parent: () => stripContext(parentContext),
         });
     }
     return parentContext;
@@ -248,38 +248,13 @@ function stripContext(ctx) {
     return {
         value: ctx.value,
         meta: ctx.meta,
-        parent: ctx.parent
+        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 isFunction(Proxy);
@@ -290,7 +265,7 @@ function isProxySupported() {
 }
 
 function ruleReturn(pass, message) {
-    var output = { pass: pass };
+    const output = { pass };
     if (message) {
         output.message = message;
     }
@@ -306,17 +281,13 @@ 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 (isBoolean(result)) {
         return ruleReturn(result);
     }
-    return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args, false)));
+    return ruleReturn(result.pass, optionalFunctionValue(result.message, ruleName, value, ...args));
 }
 function validateResult(result) {
     // if result is boolean, or if result.pass is boolean
@@ -325,55 +296,51 @@ function validateResult(result) {
 
 // eslint-disable-next-line max-lines-per-function
 function enforceEager(value) {
-    var target = {
-        message: message
+    const target = {
+        message,
     };
-    var customMessage = undefined;
+    let customMessage = undefined;
     // 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) {
+        eachEnforceRule((ruleName, ruleFn) => {
             // We then wrap the rule with `genRuleCall` that adds the base enforce behavior
             target[ruleName] = genRuleCall(target, ruleFn, ruleName);
         });
         return target;
     }
     // We create a proxy intercepting access to the target object (which is empty).
-    var proxy = new Proxy(target, {
-        get: function (_, key) {
+    const proxy = new Proxy(target, {
+        get: (_, key) => {
             // On property access, we identify if it is a rule or not.
-            var rule = getRule(key);
+            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, 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 (!isNullish(customMessage))
                     return StringObject(customMessage);
                 if (isNullish(transformedResult.message)) {
-                    return "enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value));
+                    return `enforce/${ruleName} failed with ${JSON.stringify(value)}`;
                 }
                 return StringObject(transformedResult.message);
             }
@@ -391,39 +358,33 @@ function enforceEager(value) {
 
 // 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(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(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 = 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) {
+                eachEnforceRule((ruleName) => {
                     proxy[ruleName] = addLazyRule(ruleName);
                 });
                 return proxy;
@@ -431,12 +392,12 @@ function genEnforceLazy(key) {
             // 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;
         };
@@ -470,16 +431,16 @@ 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) => {
             assign(baseRules, customRules);
             handleNoProxy(); // TODO: REMOVE when we stop supporting ES5
-        }
+        },
     };
     handleNoProxy();
     return new Proxy(assign(enforceEager, target), {
-        get: function (target, key) {
+        get: (target, key) => {
             if (key in target) {
                 return target[key];
             }
@@ -488,11 +449,11 @@ function genEnforce() {
             }
             // Only on the first rule access - start the chain of calls
             return genEnforceLazy(key);
-        }
+        },
     });
     function handleNoProxy() {
         if (!isProxySupported()) {
-            eachEnforceRule(function (ruleName) {
+            eachEnforceRule((ruleName) => {
                 // Only on the first rule access - start the chain of calls
                 target[ruleName] = genEnforceLazy(ruleName);
             });
@@ -500,6 +461,6 @@ function genEnforce() {
         }
     }
 }
-var enforce = genEnforce();
+const enforce = genEnforce();
 
 export { ctx, enforce };

package/dist/es/n4s.production.js

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

package/dist/es/schema.development.js

@@ -1,8 +1,8 @@
-import { defaultTo, mapFirst, isNullish, hasOwnProperty } from 'vest-utils';
 import { ctx, enforce } from 'n4s';
+import { defaultTo, mapFirst, isNullish, hasOwnProperty } from 'vest-utils';
 
 function ruleReturn(pass, message) {
-    var output = { pass: pass };
+    const output = { pass };
     if (message) {
         output.message = message;
     }
@@ -28,27 +28,20 @@ function runLazyRule(lazyRule, currentValue) {
 }
 
 function isArrayOf(inputArray, currentRule) {
-    return defaultToPassing(mapFirst(inputArray, function (currentValue, breakout, index) {
-        var res = ctx.run({ value: currentValue, set: true, meta: { index: index } }, function () { return runLazyRule(currentRule, currentValue); });
+    return defaultToPassing(mapFirst(inputArray, (currentValue, breakout, index) => {
+        const res = 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 = 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 = 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();
 }
@@ -61,11 +54,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 (!hasOwnProperty(shapeObject, key)) {
             return failing();
         }
@@ -76,13 +69,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] = enforce.optional(shapeObject[key]);
     }
     return output;
 }
 
-enforce.extend({ isArrayOf: isArrayOf, loose: loose, optional: optional, shape: shape });
+enforce.extend({ isArrayOf, loose, optional, shape });
 
 export { partial };

package/dist/es/schema.production.js

@@ -1 +1 @@
-import{defaultTo as r,mapFirst as n,isNullish as t,hasOwnProperty as u}from"vest-utils";import{ctx as e,enforce as o}from"n4s";function a(r,n){var t={pass:r};return n&&(t.message=n),t}function i(){return a(!1)}function f(){return a(!0)}function s(r,n){try{return r.run(n)}catch(r){return i()}}function c(r,n){var t=function(t){var u=r[t],o=n[t],a=e.run({value:u,set:!0,meta:{key:t}},(function(){return s(o,u)}));if(!a.pass)return{value:a}};for(var u in n){var o=t(u);if("object"==typeof o)return o.value}return f()}function v(r){var n={};for(var t in r)n[t]=o.optional(r[t]);return n}o.extend({isArrayOf:function(t,u){return o=n(t,(function(r,n,t){var o=e.run({value:r,set:!0,meta:{index:t}},(function(){return s(u,r)}));n(!o.pass,o)})),r(o,f());var o},loose:c,optional:function(r,n){return t(r)?f():s(n,r)},shape:function(r,n){var t=c(r,n);if(!t.pass)return t;for(var e in r)if(!u(n,e))return i();return f()}});export{v as partial};
+import{ctx as n,enforce as t}from"n4s";import{defaultTo as r,mapFirst as o,isNullish as e,hasOwnProperty as u}from"vest-utils";function s(n,t){const r={pass:n};return t&&(r.message=t),r}function i(){return s(!1)}function c(){return s(!0)}function f(n,t){try{return n.run(t)}catch(n){return i()}}function a(t,r){for(const o in r){const e=t[o],u=r[o],s=n.run({value:e,set:!0,meta:{key:o}},(()=>f(u,e)));if(!s.pass)return s}return c()}function p(n){const r={};for(const o in n)r[o]=t.optional(n[o]);return r}t.extend({isArrayOf:function(t,e){return u=o(t,((t,r,o)=>{const u=n.run({value:t,set:!0,meta:{index:o}},(()=>f(e,t)));r(!u.pass,u)})),r(u,c());var u},loose:a,optional:function(n,t){return e(n)?c():f(t,n)},shape:function(n,t){const r=a(n,t);if(!r.pass)return r;for(const r in n)if(!u(t,r))return i();return c()}});export{p as partial};