vest 4.0.0-dev-31f012 → 4.0.0-dev-e266d9

package/CHANGELOG.md

@@ -4,75 +4,93 @@ 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-12-12
 ### Changed or removed
-- f5ba507  major(context): used named export in context (ealush)
-- eaed68f  breaking(vest, enforce): prepare next major (ealush)
+- 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
-- 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)
+- 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
-- 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)
+- 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
-- 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,113 +1,3 @@
-![Vest](https://cdn.jsdelivr.net/gh/ealush/vest@assets/vest-logo.png 'Vest')
+# Vest
 
-# Vest 🦺 Declarative Validation Testing
-
-![Github Stars](https://githubbadges.com/star.svg?user=ealush&repo=vest&style=flat)
-![Npm downloads](https://img.shields.io/npm/dt/vest?label=Downloads&logo=npm)
-
-[![npm version](https://badge.fury.io/js/vest.svg)](https://badge.fury.io/js/vest) [![Build Status](https://travis-ci.org/ealush/vest.svg?branch=latest)](https://travis-ci.org/ealush/vest) [![Known Vulnerabilities](https://snyk.io/test/npm/vest/badge.svg)](https://snyk.io/test/npm/vest)
-![minifiedSize](https://img.shields.io/bundlephobia/min/vest?color=blue&logo=npm)
-
-[![Join discord](https://img.shields.io/discord/757686103292641312?label=Join%20Discord&logo=discord&logoColor=green)](https://discord.gg/WmADZpJnSe)
-
-- [Documentation homepage](https://vestjs.dev)
-- **Try vest live**
-  - [Vanilla JS Example](https://stackblitz.com/edit/vest-vanilla-support-example?file=validation.js)
-  - ReactJS Examples:
-    - [Example 1 (groups)](https://codesandbox.io/s/ecstatic-waterfall-4i2ne?file=/src/validate.js)
-    - [Example 2 (Async)](https://codesandbox.io/s/youthful-williamson-loijb?file=/src/validate.js)
-    - [Example 3](https://stackblitz.com/edit/vest-react-support-example?file=validation.js)
-    - [Example 4](https://stackblitz.com/edit/vest-react-registration?file=validate.js)
-    - [Example 5 (Password validator)](https://codesandbox.io/s/password-validator-example-6puvy?file=/src/validate.js)
-  - [VueJS Example](https://codesandbox.io/s/vest-vue-example-1j6r8?file=/src/validations.js)
-  - [Svelte Example](https://codesandbox.io/s/vestdocssvelteexample-k87t7?file=/validate.js)
-
-## Tutorials
-
-[Step By Step React Tutorial](https://dev.to/ealush/dead-simple-form-validation-with-vest-5gf8)
-
-## [Release Notes](https://github.com/ealush/vest/releases)
-
-## 🦺 What is Vest?
-
-Vest is a validations library for JS apps that derives its syntax from modern JS unit testing frameworks such as Mocha or Jest. It is easy to learn due to its use of already common declarative patterns.
-It works great with user-input validation and with validating upon user interaction to provide the best possible user experience.
-
-The idea behind Vest is that your validations can be described as a 'spec' or a contract that reflects your form or feature structure. Your validations run in production, and they are framework agnostic - meaning Vest works well with React, Angular, Vue, or even without a framework at all.
-
-Using Vest for form validation can reduce bloat, improve feature readability and maintainability.
-
-**Basic Example**
-![full](https://cdn.jsdelivr.net/gh/ealush/vest@assets/demos/full_3.gif 'full')
-
-**Memoized async test**
-![memo](https://cdn.jsdelivr.net/gh/ealush/vest@assets/demos/memo.gif 'memo')
-
-## ✅ 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 is easier to maintain over time and refactor when needed.
-
-## ✨ Vest's features
-
-- 🎨 Framework agnostic (BYOUI)
-- ⚡️ Rich, extendable, assertions library (enforce) ([doc](http://vestjs.dev/#/enforce))
-- 🚥 Multiple validations for the same field
-- ⚠️ Warning (non failing) tests ([doc](http://vestjs.dev/#/warn))
-- 📝 Validate only the fields the user interacted with ([doc](http://vestjs.dev/#/exclusion))
-- ⏳ Memoize async validations to reduce calls to the server ([doc](http://vestjs.dev/#/test?id=testmemo-for-memoized-tests))
-- 🚦 Test grouping ([doc](http://vestjs.dev/#/group))
-
-## Example code ([Run in sandbox](https://codesandbox.io/s/vest-react-tutorial-finished-ztt8t?file=/src/validate.js))
-
-```js
-import { create, only, test, enforce, warn, skipWhen } from 'vest';
-
-export default create((data = {}, currentField) => {
-  only(currentField);
-
-  test('username', 'Username is required', () => {
-    enforce(data.username).isNotEmpty();
-  });
-
-  test('username', 'Username is too short', () => {
-    enforce(data.username).longerThanOrEquals(3);
-  });
-
-  test('password', 'Password is required', () => {
-    enforce(data.password).isNotEmpty();
-  });
-
-  test('password', 'Password must be at least 6 chars long', () => {
-    enforce(data.password).longerThanOrEquals(6);
-  });
-
-  test('password', 'Password is weak, Maybe add a number?', () => {
-    warn();
-    enforce(data.password).matches(/[0-9]/);
-  });
-
-  skipWhen(!data.password, () => {
-    test('confirm_password', 'Passwords do not match', () => {
-      enforce(data.confirm_password).equals(data.password);
-    });
-  });
-
-  test('email', 'Email Address is not valid', () => {
-    enforce(data.email).isEmail();
-  });
-
-  test('tos', () => {
-    enforce(data.tos).isTruthy();
-  });
-});
-```
-
-## Why Vest?
-
-- 🧠 Vest is really easy to learn. You can take your existing knowledge of unit tests and transfer it to validations.
-- ✏️ Vest takes into account user interaction and warn only validations.
-- 🧱 Your validations are structured, making it very simple to read and write. All validation files look the same.
-- 🖇 Your validation logic is separate from your feature logic, preventing the spaghetti code that's usually involved with writing validations.
-- 🧩 Validation logic is easy to share and reuse across features.
+Home of the Vest source code.

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"}