vest 4.0.0-dev-31f012 → 4.0.0-next-0370fc

package/CHANGELOG.md

@@ -4,75 +4,86 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## 4.0.0 - 2021-10-31
+## 4.0.0 - 2021-11-21
 ### Changed or removed
-- f5ba507  major(context): used named export in context (ealush)
-- eaed68f  breaking(vest, enforce): prepare next major (ealush)
+- 7c43eab  major(context): used named export in context (ealush)
+- e8652bc  breaking(vest, enforce): prepare next major (ealush)
+- dab8e00  breaking(vest, enforce): prepare next major (ealush)
 
 ### Added
-- e0f0f91  feat(vest): support custom optional logic (ealush)
-- d4fecee  feat(vest): Add a parser export (ealush)
-- e72498d  feat(vest): isValid with field name (ealush)
-- f60d952  feat(vest): handle execution order state refill with memoized tests (ealush)
-- a2b60c4  feat(vest): Make the state rely on execution order. Make skipWhen set skipped context. (undefined)
-- ae5eb02  added(n4s): partial rule modifier (undefined)
-- 990c68f  feat(n4s): context propagation within enforce (undefined)
+- d3e7613  feat(vest): support custom optional logic (ealush)
+- be1cbf6  feat(vest): Add a parser export (ealush)
+- 2553748  feat(vest): isValid with field name (ealush)
+- ec5ceb9  feat(vest): handle execution order state refill with memoized tests (ealush)
+- 4032bd8  feat(vest): Make the state rely on execution order. Make skipWhen set skipped context. (undefined)
+- 220127b  added(n4s): partial rule modifier (undefined)
+- b5ce72d  feat(n4s): context propagation within enforce (undefined)
 
 ### Fixed and improved
-- 31f0123  patch(vest): move creation functions to event bus (ealush)
-- d23641c  patch: Some cleanups (ealush)
-- 7acb76f  fix(vest): prevent pending tests from being marked as skipped (ealush)
-- 8851ff5  patch(vest): Add isolate module for containing re-orders (ealush)
-- 0593c0f  patch(vest): refresh tests after cancel (ealush)
-- e915b53  patch: add cursor util (ealush)
-- f54ae8b  patch(vest): move cursor into context (ealush)
-- fc7627e  patch(vest): automatically purge not-found test results (ealush)
-- d68d990  vx: correctly pass cli options to build script (ealush)
-- 7c47b9a  patch(vest): Throw error when tests are called in the wrong order (ealush)
-- 01be84e  vx: add types to exports (ealush)
-- 7201170  organize vest state hooks (ealush)
-- e39bfd8  patch(vest): infer omitted optional fields (ealush)
-- 93014e3  vx: add dev bundle to exports (ealush)
-- 91df42e  fix(vest): prevent changing test status once it was finalized (ealush)
-- 797df3e  patch(vest): add cache invalidation for canceled tests (ealush)
-- 14ba6d9  types(vest): add safeguard around shouldUseErrorAsMessage (ealush)
-- 477ca00  patch(vest): some cleanups (ealush)
-- 58d5ed3  patch(vest): remove duplicate code handling perv test registration (ealush)
-- 6a98443  vx: use context directly from published package (ealush)
-- a79e479  patch: run done callbacks via event (ealush)
-- 01d32b7  patch(vest): removed state subscription (ealush)
+- 0370fc1  n4s: extract non-required modules (ealush)
+- 03ba92c  vx: support namespaced exports (ealush)
+- 38a54ae  vx: support installing of local packages (ealush)
+- 7baedf2  n4s: use named export in entry (ealush)
+- 366001b  patch(vest): better handling of skipped async tests (ealush)
+- 2380679  types(vest): allow unprovided suite name in tests (ealush)
+- f721b2d  patch(vest): replace warns boolean flag with enum (ealush)
+- 0acb24d  patch(vest): Pass draft result to skipWhen conditional (ealush)
+- e84cd9d  patch(vest): add back optional suite name argument (ealush)
+- 8b30b66  patch(vest): make compose an external export (ealush)
+- ddfa9fd  patch(vest): move creation functions to event bus (ealush)
+- fe83e88  patch: Some cleanups (ealush)
+- 9275707  fix(vest): prevent pending tests from being marked as skipped (ealush)
+- 94e00a8  patch(vest): Add isolate module for containing re-orders (ealush)
+- 5bcc14a  patch(vest): refresh tests after cancel (ealush)
+- fd049e8  patch: add cursor util (ealush)
+- 9380c09  patch(vest): move cursor into context (ealush)
+- 49b72f4  patch(vest): automatically purge not-found test results (ealush)
+- 2dfedaf  vx: correctly pass cli options to build script (ealush)
+- aae250a  patch(vest): Throw error when tests are called in the wrong order (ealush)
+- a87824b  vx: add types to exports (ealush)
+- cc9b4b0  organize vest state hooks (ealush)
+- df84261  patch(vest): infer omitted optional fields (ealush)
+- 2534cf6  vx: add dev bundle to exports (ealush)
+- 4d450aa  fix(vest): prevent changing test status once it was finalized (ealush)
+- 8730e25  patch(vest): add cache invalidation for canceled tests (ealush)
+- 4cb2c6c  types(vest): add safeguard around shouldUseErrorAsMessage (ealush)
+- c214a12  patch(vest): some cleanups (ealush)
+- 858458d  patch(vest): remove duplicate code handling perv test registration (ealush)
+- ec69173  vx: use context directly from published package (ealush)
+- 962bc06  patch: run done callbacks via event (ealush)
+- d96f428  patch(vest): removed state subscription (ealush)
 - package.json
 - packages/anyone/package.json
 - packages/anyone/package.json
 - packages/vast/types/vast.d.ts
-- b10b98b  patch(vest): remove pending and lagging state (ealush)
-- dfd2cc3  patch(vest): convert boolean flags to a single status key (ealush)
-- 1c9da6c  patch: simplify fieldname comparison (ealush)
-- 43c75a4  patch(vest): add useAllIncomplete hook (ealush)
-- 2dfdc97  patch(vest): invalid accounts for warning tests as well (ealush)
-- 4033cca  patch(vest): isValid counts all required tests per field (ealush)
-- 02b28a6  chore: cleanups (ealush)
+- e4e1746  patch(vest): remove pending and lagging state (ealush)
+- 9d8fd21  patch(vest): convert boolean flags to a single status key (ealush)
+- dbb836e  patch: simplify fieldname comparison (ealush)
+- 5a78179  patch(vest): add useAllIncomplete hook (ealush)
+- b5ae658  patch(vest): invalid accounts for warning tests as well (ealush)
+- 4563b8d  patch(vest): isValid counts all required tests per field (ealush)
+- 3fe2f21  chore: cleanups (ealush)
 - .eslintrc.js
-- afa16e9  add(n4s): enforce.condition (ealush)
+- 149aab3  add(n4s): enforce.condition (ealush)
 - package.json
 - packages/anyone/package.json
-- d452e26  chore: cleanup residue (undefined)
-- 5982183  chore: remove duplicate types (undefined)
+- 40ef071  chore: cleanup residue (undefined)
+- eeac20e  chore: remove duplicate types (undefined)
 - packages/anyone/package.json
-- 52ac8e0  patch: add nodejs exports (undefined)
-- f9c4b3e  patch: remove unused exports (undefined)
+- 4d88c04  patch: add nodejs exports (undefined)
+- 6e57aa1  patch: remove unused exports (undefined)
 - packages/anyone/package.json
-- db0253b  chore: reduce complexity, remove all lint errors (undefined)
+- 26af06b  chore: reduce complexity, remove all lint errors (undefined)
 - packages/anyone/.npmignore
 - .github/PULL_REQUEST_TEMPLATE.md
-- be9c776  chore: cleanup unused code (ealush)
-- c5eb2de  lint: handling lint of all packages (ealush)
+- 5be986d  chore: cleanup unused code (ealush)
+- ba68539  lint: handling lint of all packages (ealush)
 - .gitignore
-- d388fdc  patch(n4s): add ruleReturn default values (ealush)
-- be91b7e  fix(n4s): make enforce compound runners fall back to correct response (ealush)
-- 7e8f25c  fix(n4s): make enforce chaining work (ealush)
-- e60ce3b  chore: some lint fixes (ealush)
-- fc8e2d8  add cli options support (ealush)
+- cca5130  patch(n4s): add ruleReturn default values (ealush)
+- 75306ff  fix(n4s): make enforce compound runners fall back to correct response (ealush)
+- 4751584  fix(n4s): make enforce chaining work (ealush)
+- 73b28a1  chore: some lint fixes (ealush)
+- 4135ce3  add cli options support (ealush)
 
 ## 3.2.7 - 2021-07-17
 

package/README.md

@@ -1,5 +1,17 @@
 ![Vest](https://cdn.jsdelivr.net/gh/ealush/vest@assets/vest-logo.png 'Vest')
 
+# Version 4 of Vest is coming soon!
+
+If you want to try it out, you can already install it with the `next` tag.
+
+```npm install vest@next```
+
+This version brings many enhancements to Vest. This version is well tested, and can be used safely. If you do, however encounter any issues or have any thoughts on the next version, please report them on the issues page.
+
+For the version 4 docs, you can reach out to: https://vest.vercel.app/ or specifically to the [migration guide](https://vest.vercel.app/docs/migration_guide).
+
+A note on Typescript support: Version four uses Typescript 4 specific features, so for now only version 4 is supported.
+
 # Vest 🦺 Declarative Validation Testing
 
 ![Github Stars](https://githubbadges.com/star.svg?user=ealush&repo=vest&style=flat)

package/dist/cjs/compose.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./compose.production.js');
+} else {
+  module.exports = require('./compose.development.js');
+}

package/dist/cjs/compounds.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./compounds.production.js');
+} else {
+  module.exports = require('./compounds.development.js');
+}

package/dist/cjs/enforce/compose.development.js

@@ -0,0 +1,139 @@
+'use strict';
+
+var n4s = require('n4s');
+
+function mapFirst(array, callback) {
+    var broke = false;
+    var breakoutValue = null;
+    for (var i = 0; i < array.length; i++) {
+        callback(array[i], breakout, i);
+        if (broke) {
+            return breakoutValue;
+        }
+    }
+    function breakout(value) {
+        broke = true;
+        breakoutValue = value;
+    }
+}
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function optionalFunctionValue(value) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return isFunction(value) ? value.apply(void 0, args) : value;
+}
+
+function defaultTo(callback, defaultValue) {
+    var _a;
+    return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
+}
+
+/**
+ * Throws a timed out error.
+ */
+function throwError(devMessage, productionMessage) {
+    throw new Error(devMessage );
+}
+
+/**
+ * A safe hasOwnProperty access
+ */
+function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function isNumber(value) {
+    return Boolean(typeof value === 'number');
+}
+
+function lengthEquals(value, arg1) {
+    return value.length === Number(arg1);
+}
+
+function isEmpty(value) {
+    if (!value) {
+        return true;
+    }
+    else if (isNumber(value)) {
+        return value === 0;
+    }
+    else if (hasOwnProperty(value, 'length')) {
+        return lengthEquals(value, 0);
+    }
+    else if (typeof value === 'object') {
+        return lengthEquals(Object.keys(value), 0);
+    }
+    return true;
+}
+
+function ruleReturn(pass, message) {
+    var output = { pass: pass };
+    if (message) {
+        output.message = message;
+    }
+    return output;
+}
+function failing() {
+    return ruleReturn(false);
+}
+function passing() {
+    return ruleReturn(true);
+}
+function defaultToPassing(callback) {
+    return defaultTo(callback, passing());
+}
+
+function runLazyRule(lazyRule, currentValue) {
+    try {
+        return lazyRule.run(currentValue);
+    }
+    catch (_a) {
+        return failing();
+    }
+}
+
+/* eslint-disable max-lines-per-function */
+function compose() {
+    var composites = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        composites[_i] = arguments[_i];
+    }
+    return Object.assign(function (value) {
+        var res = run(value);
+        if (!res.pass) {
+            if (isEmpty(res.message)) {
+                throwError();
+            }
+            else {
+                // Explicitly throw a string so that vest.test can pick it up as the validation error message
+                throw res.message;
+            }
+        }
+    }, {
+        run: run,
+        test: function (value) { return run(value).pass; }
+    });
+    function run(value) {
+        return n4s.ctx.run({ value: value }, function () {
+            return defaultToPassing(mapFirst(composites, function (composite, breakout) {
+                /* HACK: Just a small white lie. ~~HELP WANTED~~.
+                   The ideal is that instead of `TLazyRuleRunners` We would simply use `TLazy` to begin with.
+                   The problem is that lazy rules can't really be passed to this function due to some generic hell
+                   so we're limiting it to a small set of functions.
+                */
+                var res = runLazyRule(composite, value);
+                if (!res.pass) {
+                    breakout(res);
+                }
+            }));
+        });
+    }
+}
+
+module.exports = compose;

package/dist/cjs/enforce/compose.production.js

@@ -0,0 +1 @@
+"use strict";var n=require("n4s");function r(n,r){function t(n){u=!0,e=n}for(var u=!1,e=null,o=0;o<n.length;o++)if(r(n[o],t,o),u)return e}function t(n){return"function"==typeof n}function u(n,r){var u;return null!==(u=function(n){for(var r=[],u=1;u<arguments.length;u++)r[u-1]=arguments[u];return t(n)?n.apply(void 0,r):n}(n))&&void 0!==u?u:r}function e(n,r){throw Error(u(r,n))}function o(n,r){return n.length===Number(r)}function f(n){if(n){if(function(n){return"number"==typeof n}(n))return 0===n;if(function(n,r){return Object.prototype.hasOwnProperty.call(n,r)}(n,"length"))return o(n,0);if("object"==typeof n)return o(Object.keys(n),0)}return!0}function i(n,r){return n={pass:n},r&&(n.message=r),n}function c(n){return u(n,i(!0))}function s(n,r){try{return n.run(r)}catch(n){return i(!1)}}module.exports=function(){function t(t){return n.ctx.run({value:t},(function(){return c(r(u,(function(n,r){(n=s(n,t)).pass||r(n)})))}))}for(var u=[],o=0;o<arguments.length;o++)u[o]=arguments[o];return Object.assign((function(n){if(!(n=t(n)).pass){if(!f(n.message))throw n.message;e()}}),{run:t,test:function(n){return t(n).pass}})};

package/dist/cjs/enforce/compounds.development.js

@@ -0,0 +1,147 @@
+'use strict';
+
+var n4s = require('n4s');
+
+function mapFirst(array, callback) {
+    var broke = false;
+    var breakoutValue = null;
+    for (var i = 0; i < array.length; i++) {
+        callback(array[i], breakout, i);
+        if (broke) {
+            return breakoutValue;
+        }
+    }
+    function breakout(value) {
+        broke = true;
+        breakoutValue = value;
+    }
+}
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function optionalFunctionValue(value) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return isFunction(value) ? value.apply(void 0, args) : value;
+}
+
+function defaultTo(callback, defaultValue) {
+    var _a;
+    return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
+}
+
+function ruleReturn(pass, message) {
+    var output = { pass: pass };
+    if (message) {
+        output.message = message;
+    }
+    return output;
+}
+function failing() {
+    return ruleReturn(false);
+}
+function passing() {
+    return ruleReturn(true);
+}
+function defaultToFailing(callback) {
+    return defaultTo(callback, failing());
+}
+function defaultToPassing(callback) {
+    return defaultTo(callback, passing());
+}
+
+function runLazyRule(lazyRule, currentValue) {
+    try {
+        return lazyRule.run(currentValue);
+    }
+    catch (_a) {
+        return failing();
+    }
+}
+
+function allOf(value) {
+    var rules = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rules[_i - 1] = arguments[_i];
+    }
+    return defaultToPassing(mapFirst(rules, function (rule, breakout) {
+        var res = runLazyRule(rule, value);
+        if (!res.pass) {
+            breakout(res);
+        }
+    }));
+}
+
+function anyOf(value) {
+    var rules = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rules[_i - 1] = arguments[_i];
+    }
+    return defaultToFailing(mapFirst(rules, function (rule, breakout) {
+        var res = runLazyRule(rule, value);
+        if (res.pass) {
+            breakout(res);
+        }
+    }));
+}
+
+function noneOf(value) {
+    var rules = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rules[_i - 1] = arguments[_i];
+    }
+    return defaultToPassing(mapFirst(rules, function (rule, breakout) {
+        var res = runLazyRule(rule, value);
+        if (res.pass) {
+            breakout(failing());
+        }
+    }));
+}
+
+function lengthEquals(value, arg1) {
+    return value.length === Number(arg1);
+}
+
+function longerThan(value, arg1) {
+    return value.length > Number(arg1);
+}
+
+var REQUIRED_COUNT = 1;
+function oneOf(value) {
+    var rules = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rules[_i - 1] = arguments[_i];
+    }
+    var passing = [];
+    rules.some(function (rule) {
+        if (longerThan(passing, REQUIRED_COUNT)) {
+            return false;
+        }
+        var res = runLazyRule(rule, value);
+        if (res.pass) {
+            passing.push(res);
+        }
+    });
+    return ruleReturn(lengthEquals(passing, REQUIRED_COUNT));
+}
+
+function isNull(value) {
+    return value === null;
+}
+
+function isUndefined(value) {
+    return value === undefined;
+}
+
+function optional(value, ruleChain) {
+    if (isUndefined(value) || isNull(value)) {
+        return passing();
+    }
+    return runLazyRule(ruleChain, value);
+}
+
+n4s.enforce.extend({ allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf, optional: optional });

package/dist/cjs/enforce/compounds.production.js

@@ -0,0 +1 @@
+"use strict";var n=require("n4s");function r(n,r){function t(n){u=!0,e=n}for(var u=!1,e=null,o=0;o<n.length;o++)if(r(n[o],t,o),u)return e}function t(n){return"function"==typeof n}function u(n,r){var u;return null!==(u=function(n){for(var r=[],u=1;u<arguments.length;u++)r[u-1]=arguments[u];return t(n)?n.apply(void 0,r):n}(n))&&void 0!==u?u:r}function e(n,r){return n={pass:n},r&&(n.message=r),n}function o(){return e(!1)}function f(){return e(!0)}function i(n){return u(n,o())}function c(n){return u(n,f())}function a(n,r){try{return n.run(r)}catch(n){return o()}}function l(n,r){return n.length===Number(r)}function s(n,r){return n.length>Number(r)}n.enforce.extend({allOf:function(n){for(var t=[],u=1;u<arguments.length;u++)t[u-1]=arguments[u];return c(r(t,(function(r,t){(r=a(r,n)).pass||t(r)})))},anyOf:function(n){for(var t=[],u=1;u<arguments.length;u++)t[u-1]=arguments[u];return i(r(t,(function(r,t){(r=a(r,n)).pass&&t(r)})))},noneOf:function(n){for(var t=[],u=1;u<arguments.length;u++)t[u-1]=arguments[u];return c(r(t,(function(r,t){a(r,n).pass&&t(o())})))},oneOf:function(n){for(var r=[],t=1;t<arguments.length;t++)r[t-1]=arguments[t];var u=[];return r.some((function(r){if(s(u,1))return!1;(r=a(r,n)).pass&&u.push(r)})),e(l(u,1))},optional:function(n,r){return function(n){return void 0===n}(n)||function(n){return null===n}(n)?f():a(r,n)}});

package/dist/cjs/enforce/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/enforce/schema.development.js

@@ -0,0 +1,111 @@
+'use strict';
+
+var n4s = require('n4s');
+
+function mapFirst(array, callback) {
+    var broke = false;
+    var breakoutValue = null;
+    for (var i = 0; i < array.length; i++) {
+        callback(array[i], breakout, i);
+        if (broke) {
+            return breakoutValue;
+        }
+    }
+    function breakout(value) {
+        broke = true;
+        breakoutValue = value;
+    }
+}
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function optionalFunctionValue(value) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return isFunction(value) ? value.apply(void 0, args) : value;
+}
+
+function defaultTo(callback, defaultValue) {
+    var _a;
+    return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
+}
+
+function ruleReturn(pass, message) {
+    var output = { pass: pass };
+    if (message) {
+        output.message = message;
+    }
+    return output;
+}
+function failing() {
+    return ruleReturn(false);
+}
+function passing() {
+    return ruleReturn(true);
+}
+function defaultToPassing(callback) {
+    return defaultTo(callback, passing());
+}
+
+function runLazyRule(lazyRule, currentValue) {
+    try {
+        return lazyRule.run(currentValue);
+    }
+    catch (_a) {
+        return failing();
+    }
+}
+
+function isArrayOf(inputArray, currentRule) {
+    return defaultToPassing(mapFirst(inputArray, function (currentValue, breakout, index) {
+        var res = n4s.ctx.run({ value: currentValue, set: true, meta: { index: index } }, function () { return runLazyRule(currentRule, currentValue); });
+        if (!res.pass) {
+            breakout(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);
+        });
+        if (!res.pass) {
+            return { value: res };
+        }
+    };
+    for (var key in shapeObject) {
+        var state_1 = _loop_1(key);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return passing();
+}
+
+/**
+ * A safe hasOwnProperty access
+ */
+function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function shape(inputObject, shapeObject) {
+    var baseRes = loose(inputObject, shapeObject);
+    if (!baseRes.pass) {
+        return baseRes;
+    }
+    for (var key in inputObject) {
+        if (!hasOwnProperty(shapeObject, key)) {
+            return failing();
+        }
+    }
+    return passing();
+}
+
+n4s.enforce.extend({ shape: shape, loose: loose, isArrayOf: isArrayOf });

package/dist/cjs/enforce/schema.production.js

@@ -0,0 +1 @@
+"use strict";var n=require("n4s");function r(n){return"function"==typeof n}function t(n,t){var u;return null!==(u=function(n){for(var t=[],u=1;u<arguments.length;u++)t[u-1]=arguments[u];return r(n)?n.apply(void 0,t):n}(n))&&void 0!==u?u:t}function u(n,r){return n={pass:n},r&&(n.message=r),n}function e(){return u(!1)}function o(){return u(!0)}function f(n,r){try{return n.run(r)}catch(n){return e()}}function i(r,t){var u,e=function(u){var e=r[u],o=t[u];if(!(u=n.ctx.run({value:e,set:!0,meta:{key:u}},(function(){return f(o,e)}))).pass)return{value:u}};for(u in t){var i=e(u);if("object"==typeof i)return i.value}return o()}function c(n,r){return Object.prototype.hasOwnProperty.call(n,r)}n.enforce.extend({shape:function(n,r){var t=i(n,r);if(!t.pass)return t;for(var u in n)if(!c(r,u))return e();return o()},loose:i,isArrayOf:function(r,u){return function(n){return t(n,o())}(function(n,r){function t(n){u=!0,e=n}for(var u=!1,e=null,o=0;o<n.length;o++)if(r(n[o],t,o),u)return e}(r,(function(r,t,e){(e=n.ctx.run({value:r,set:!0,meta:{index:e}},(function(){return f(u,r)}))).pass||t(e)})))}});

package/dist/cjs/schema.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./schema.production.js');
+} else {
+  module.exports = require('./schema.development.js');
+}