vest 4.0.0-next-c704bc → 4.0.1-dev-6078f7

package/CHANGELOG.md

@@ -4,95 +4,6 @@ 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-12-17
-### Changed or removed
-- b5a0108  breaking(vest): remove test.each (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
-- b0a9a14  feat(vest): use key prop to retain test state after reorder (#732) (Evyatar)
-- 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
-- c704bc9  add(vest): omitWhen (#738) (Evyatar)
-- 1384c08  fix(vest): only.group works in conjunction with only (#734) (Evyatar)
-- README.md
-- 7daf6d2  rule(n4s): add isNullish rule, improve isBlank (ealush)
-- c4a4140  chore: organize imports (ealush)
-- 9f9b970  vx: improve package.json generation (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
-- 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
-- 149aab3  add(n4s): enforce.condition (ealush)
-- package.json
-- packages/anyone/package.json
-- 40ef071  chore: cleanup residue (undefined)
-- eeac20e  chore: remove duplicate types (undefined)
-- packages/anyone/package.json
-- 4d88c04  patch: add nodejs exports (undefined)
-- 6e57aa1  patch: remove unused exports (undefined)
-- packages/anyone/package.json
-- 26af06b  chore: reduce complexity, remove all lint errors (undefined)
-- packages/anyone/.npmignore
-- .github/PULL_REQUEST_TEMPLATE.md
-- 5be986d  chore: cleanup unused code (ealush)
-- ba68539  lint: handling lint of all packages (ealush)
-- .gitignore
-- 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
 
 ### Fixed and improved

package/README.md

@@ -1,3 +1,58 @@
-# Vest
+# Vest - Declarative validations framework
 
-Home of the Vest source code.
+[Vest Documentation](https://vestjs.dev)
+
+[![Join Discord](https://badgen.net/discord/online-members/WmADZpJnSe?icon=discord&label=Discord)](https://discord.gg/WmADZpJnSe) [![Github Stars](https://badgen.net/github/stars/ealush/vest?color=yellow&label=Github%20🌟)](https://github.com/ealush/vest) [![Version](https://badgen.net/npm/v/vest?&icon=npm)](https://www.npmjs.com/package/vest) [![Downloads](https://badgen.net/npm/dt/vest?label=Downloads)](https://www.npmjs.com/package/vest) [![bundlephobia](https://badgen.net/bundlephobia/minzip/vest)](https://bundlephobia.com/package/vest) [![Status](https://badgen.net/github/status/ealush/vest)](https://github.com/ealush/vest/actions)
+
+![Vest](https://cdn.jsdelivr.net/gh/ealush/vest@assets/logo_250.png 'Vest')
+
+Vest is a form-validation framework inspired by unit testing libraries like Mocha or Jest; It is designed to be easy to use and easy to learn by introducing their declarative syntax.
+
+The idea behind Vest is that your validations can be described as a suite - a contract that reflects your form or feature structure. Vest is framework agnostic, meaning it can be used with any UI framework, or without any framework at all.
+
+Using Vest for form validation can reduce bloat, improve feature readability and maintainability.
+
+```js
+test('username', 'Username is required', () => {
+  enforce(data.username).isNotBlank();
+});
+
+test('username', 'Username must be at least 3 chars', () => {
+  enforce(data.username).longerThanOrEquals(3);
+});
+```
+
+## Installation
+
+```
+npm i vest
+```
+
+## Motivation
+
+Writing forms is an integral part of building web apps, and even though it may seem trivial at first - as your feature grows over time, so does your validation logic grows in complexity.
+
+Vest tries to remediate this by separating validation logic from feature logic, so it's easier to maintain over time and refactor when needed.
+
+# Why Vest?
+
+💡 Vest is easy to Learn. Vest adopts the syntax and style of unit testing frameworks, so you can leverage the knowledge you already have to write your form validations.
+
+🎨 Vest is framework agnostic. You can use Vest with any UI framework out there.
+
+🧠 Vest takes care of all the annoying parts for you. It manages its validation state, handles async validations, and much more.
+
+🧩 Vest is extendable. You can easily add new kinds of validations to Vest according to your needs.
+
+♻️ Validation logic in Vest can be shared across multiple features in your app.
+
+# Getting Started
+
+[Vest Documentation](https://vestjs.dev)
+
+Here are some code sandboxes to get you started:
+
+- [React](https://codesandbox.io/s/react-28jwx)
+- [Vue](https://codesandbox.io/s/vue-hsyt8)
+- [Svelte](https://codesandbox.io/s/svelte-tsfhx)
+- [Vanilla](https://codesandbox.io/s/vest-vanilla-js-35u8e)

package/dist/cjs/classnames.development.js

@@ -0,0 +1,77 @@
+'use strict';
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+/**
+ * Throws a timed out error.
+ */
+function throwError(devMessage, productionMessage) {
+    throw new Error(devMessage );
+}
+
+function isNumeric(value) {
+    var str = String(value);
+    var num = Number(value);
+    var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
+    return Boolean(result);
+}
+
+function greaterThan(value, gt) {
+    return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
+}
+
+/**
+ * A safe hasOwnProperty access
+ */
+function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function parse(res) {
+    var testedStorage = {};
+    var selectors = {
+        invalid: res.hasErrors,
+        tested: function (fieldName) {
+            if (!fieldName) {
+                return greaterThan(res.testCount, 0);
+            }
+            if (hasOwnProperty(testedStorage, fieldName))
+                return testedStorage[fieldName];
+            testedStorage[fieldName] =
+                hasOwnProperty(res.tests, fieldName) &&
+                    greaterThan(res.tests[fieldName].testCount, 0);
+            return selectors.tested(fieldName);
+        },
+        untested: function (fieldName) {
+            return res.testCount === 0 || !selectors.tested(fieldName);
+        },
+        valid: res.isValid,
+        warning: res.hasWarnings
+    };
+    return selectors;
+}
+
+/**
+ * Creates a function that returns class names that match the validation result
+ */
+function classnames(res, classes) {
+    if (classes === void 0) { classes = {}; }
+    if (!res || !isFunction(res.hasErrors)) {
+        throwError("classnames: Expected first argument to be Vest's result object.");
+    }
+    var selectors = parse(res);
+    return function (key) {
+        var classesArray = [];
+        for (var selector in classes) {
+            var sel = selector;
+            if (isFunction(selectors[sel]) && selectors[sel](key)) {
+                classesArray.push(classes[sel]);
+            }
+        }
+        return classesArray.join(' ');
+    };
+}
+
+module.exports = classnames;

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,132 @@
+'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));
+}
+
+n4s.enforce.extend({ allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf });

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,f=0;f<n.length;f++)if(r(n[f],t,f),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 f(){return e(!1)}function o(n){return u(n,f())}function i(n){return u(n,e(!0))}function c(n,r){try{return n.run(r)}catch(n){return f()}}function a(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 i(r(t,(function(r,t){(r=c(r,n)).pass||t(r)})))},anyOf:function(n){for(var t=[],u=1;u<arguments.length;u++)t[u-1]=arguments[u];return o(r(t,(function(r,t){(r=c(r,n)).pass&&t(r)})))},noneOf:function(n){for(var t=[],u=1;u<arguments.length;u++)t[u-1]=arguments[u];return i(r(t,(function(r,t){c(r,n).pass&&t(f())})))},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=c(r,n)).pass&&u.push(r)})),e(a(u,1))}});

package/dist/cjs/enforce/package.json

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

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

@@ -0,0 +1,144 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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();
+}
+
+function isNull(value) {
+    return value === null;
+}
+
+function isUndefined(value) {
+    return value === undefined;
+}
+
+function isNullish(value) {
+    return isNull(value) || isUndefined(value);
+}
+
+function optional(value, ruleChain) {
+    if (isNullish(value)) {
+        return passing();
+    }
+    return runLazyRule(ruleChain, value);
+}
+
+/**
+ * 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();
+}
+
+// Help needed improving the typings of this file.
+// Ideally, we'd be able to extend IShapeObject, but that's not possible.
+function partial(shapeObject) {
+    var output = {};
+    for (var key in shapeObject) {
+        output[key] = n4s.enforce.optional(shapeObject[key]);
+    }
+    return output;
+}
+
+n4s.enforce.extend({ isArrayOf: isArrayOf, loose: loose, optional: optional, shape: shape });
+
+exports.partial = partial;

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

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