n4s 3.1.0 → 4.0.0-next-03ba92

package/CHANGELOG.md

@@ -0,0 +1,120 @@
+# n4s - Changelog
+
+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-11-20
+### Changed or removed
+- 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
+- 49e601a  feat(n4s): enforce.compose (ealush)
+- 2b902cb  added(n4s): add custom message support to lazy enforcements (undefined)
+- 220127b  added(n4s): partial rule modifier (undefined)
+- b5ce72d  feat(n4s): context propagation within enforce (undefined)
+- 651de44  feat(n4s): optional (undefined)
+- 516ff54  feat(n4s): isArrayOf (undefined)
+- 32fe8a5  feat(n4s): add shape and loose validations (undefined)
+
+### Fixed and improved
+- 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)
+- 5e9194f  vx: add next release process (ealush)
+- 7473483  hack(n4s): use 'any' as the input for compose (ealush)
+- 8b30b66  patch(vest): make compose an external export (ealush)
+- fe83e88  patch: Some cleanups (ealush)
+- 780c5b7  types(n4s): Allow adding types for custom matchers (ealush)
+- 94e00a8  patch(vest): Add isolate module for containing re-orders (ealush)
+- bed7040  vx: add back to workspace (ealush)
+- aae250a  patch(vest): Throw error when tests are called in the wrong order (ealush)
+- f2d458d  update build artifacts (ealush)
+- dc99d94  patch: shorten isBlank (ealush)
+- package.json
+- packages/anyone/package.json
+- dbb836e  patch: simplify fieldname comparison (ealush)
+- 3fe2f21  chore: cleanups (ealush)
+- .eslintrc.js
+- 149aab3  add(n4s): enforce.condition (ealush)
+- packages/anyone/README.md
+- package.json
+- d786b34  fix(n4s): make sure oneOf correctly validates single case (ealush)
+- 13830b9  types(n4s): simplify the types for (ealush)
+- packages/anyone/package.json
+- 40ef071  chore: cleanup residue (undefined)
+- eeac20e  chore: remove duplicate types (undefined)
+- e4e2a80  tests(n4s): add paritla tests (undefined)
+- packages/anyone/package.json
+- 4d88c04  patch: add nodejs exports (undefined)
+- 6e57aa1  patch: remove unused exports (undefined)
+- 1dddaf4  patch(n4s): improve types for rule chaining (undefined)
+- packages/anyone/package.json
+- 97175f1  patch: simplify proxy test/run assignment (undefined)
+- 39b92f1  patch: enable enforce in es5 environments (undefined)
+- 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)
+
+## 3.1.0 - 2021-08-06
+
+### Added
+
+- bf432a1 added(n4s): add custom message support to lazy enforcements (undefined)
+- c093a7f added(n4s): partial rule modifier (undefined)
+- 045bc72 feat(n4s): context propagation within enforce (undefined)
+- 443df9d feat(n4s): optional (undefined)
+- 86172ca feat(n4s): isArrayOf (undefined)
+- f48f38b feat(n4s): add shape and loose validations (undefined)
+
+### Fixed and improved
+
+- fdcf20b genscript (undefined)
+- b12614f chore: cleanup residue (undefined)
+- 4da20b4 chore: remove duplicate types (undefined)
+- c66298d tests(n4s): add paritla tests (undefined)
+- packages/anyone/package.json
+- a8c1e67 patch: add nodejs exports (undefined)
+- 83efb86 patch: remove unused exports (undefined)
+- 9546b9e patch(n4s): improve types for rule chaining (undefined)
+- packages/anyone/package.json
+- 7bab926 patch: simplify proxy test/run assignment (undefined)
+- ed5c903 patch: enable enforce in es5 environments (undefined)
+- 3494de6 chore: reduce complexity, remove all lint errors (undefined)
+- packages/anyone/.npmignore
+- .github/PULL_REQUEST_TEMPLATE.md
+- aec6cd6 chore: cleanup unused code (ealush)
+- 0103b38 lint: handling lint of all packages (ealush)
+- .gitignore
+- 03cf487 patch(n4s): add ruleReturn default values (ealush)
+- 76e8c98 fix(n4s): make enforce compound runners fall back to correct response (ealush)
+- ff91bd2 fix(n4s): make enforce chaining work (ealush)
+- c3fd912 chore: some lint fixes (ealush)
+- 49b6b84 Vest 4 Infra Setup (ealush)
+
+## 1.1.14 - 2021-07-02
+
+### Fixed and improved
+
+- 34e0414 improved conditions (undefined)
+- 26c28c6 all tests pass (undefined)
+- 33f4e46 release (undefined)
+- 6fe40c7 better bundle (undefined)
+- c2cfb65 better typing (undefined)
+- c6387ab before ts settings (undefined)
+- c0e9708 generate correct d.ts file (undefined)
+- 8e01b8e x (undefined)
+- afb3960 x (undefined)
+- e0a8463 add changelog support (undefined)
+- cc46c38 current (undefined)
+- b6db1c6 transform any to unknowns (ealush)

package/LICENSE

@@ -1,7 +1,6 @@
 MIT License
 
 Copyright (c) 2020 ealush
-Copyright (c) 2019 Fiverr
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/README.md

@@ -7,7 +7,7 @@ By default, enforce throws an error when your validations fail. These errors sho
 You can extend Enforce per need, and you can add your custom validation rules in your app.
 
 ```js
-import enforce from 'n4s';
+import { enforce } from 'n4s';
 
 enforce(4).isNumber();
 // passes
@@ -33,10 +33,7 @@ npm i n4s
 If you wish to use enforce's functionality safely with a boolean return interface, you can use its lazy validation interface:
 
 ```js
-enforce
-  .isArray()
-  .longerThan(3)
-  .test([1,2,3])
+enforce.isArray().longerThan(3).test([1, 2, 3]);
 ```
 
 [Read the docs](https://ealush.github.io/n4s)

package/compose/package.json

@@ -0,0 +1,7 @@
+{
+  "main": "../dist/cjs/compose.js",
+  "module": "../dist/es/compose.production.js",
+  "name": "compose",
+  "types": "../types/compose.d.ts",
+  "private": true
+}

package/dist/cjs/compose.development.js

@@ -0,0 +1,222 @@
+'use strict';
+
+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 );
+}
+
+var assign = Object.assign;
+
+// eslint-disable-next-line max-lines-per-function
+function createContext(init) {
+    var storage = { ancestry: [] };
+    return {
+        bind: bind,
+        run: run,
+        use: use,
+        useX: useX
+    };
+    function useX(errorMessage) {
+        var _a;
+        return ((_a = storage.ctx) !== null && _a !== void 0 ? _a : throwError(defaultTo(errorMessage, 'Context was used after it was closed')));
+    }
+    function run(ctxRef, fn) {
+        var _a;
+        var parentContext = use();
+        var out = assign({}, parentContext ? parentContext : {}, (_a = optionalFunctionValue(init, ctxRef, parentContext)) !== null && _a !== void 0 ? _a : ctxRef);
+        var ctx = set(Object.freeze(out));
+        storage.ancestry.unshift(ctx);
+        var res = fn(ctx);
+        clear();
+        return res;
+    }
+    function bind(ctxRef, fn) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - this one's pretty hard to get right
+        var returnedFn = function () {
+            var runTimeArgs = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                runTimeArgs[_i] = arguments[_i];
+            }
+            return run(ctxRef, function () {
+                return fn.apply(void 0, runTimeArgs);
+            });
+        };
+        return returnedFn;
+    }
+    function use() {
+        return storage.ctx;
+    }
+    function set(value) {
+        return (storage.ctx = value);
+    }
+    function clear() {
+        var _a;
+        storage.ancestry.shift();
+        set((_a = storage.ancestry[0]) !== null && _a !== void 0 ? _a : null);
+    }
+}
+
+var ctx = createContext(function (ctxRef, parentContext) {
+    var base = {
+        value: ctxRef.value,
+        meta: ctxRef.meta || {}
+    };
+    if (!parentContext) {
+        return assign(base, {
+            parent: emptyParent
+        });
+    }
+    else if (ctxRef.set) {
+        return assign(base, {
+            parent: function () { return stripContext(parentContext); }
+        });
+    }
+    return parentContext;
+});
+function stripContext(ctx) {
+    if (!ctx) {
+        return ctx;
+    }
+    return {
+        value: ctx.value,
+        meta: ctx.meta,
+        parent: ctx.parent
+    };
+}
+function emptyParent() {
+    return null;
+}
+
+/**
+ * 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 */
+// TODO: This gives me a headache. Instead of `any` we should use `TLazy`
+// but it fails when using compose. The type is very complex. Feel free to help.
+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 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/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/compose.production.js

@@ -0,0 +1 @@
+"use strict";function n(n,t){function r(n){e=!0,u=n}for(var e=!1,u=null,o=0;o<n.length;o++)if(t(n[o],r,o),e)return u}function t(n){return"function"==typeof n}function r(n){for(var r=[],e=1;e<arguments.length;e++)r[e-1]=arguments[e];return t(n)?n.apply(void 0,r):n}function e(n,t){var e;return null!==(e=r(n))&&void 0!==e?e:t}function u(n,t){throw Error(e(t,n))}var o=Object.assign;var i=function(n){function t(t,e){var u,f,a=i();return t=o({},a||{},null!==(u=r(n,t,a))&&void 0!==u?u:t),u=c.ctx=Object.freeze(t),c.ancestry.unshift(u),e=e(u),c.ancestry.shift(),c.ctx=null!==(f=c.ancestry[0])&&void 0!==f?f:null,e}function i(){return c.ctx}var c={ancestry:[]};return{bind:function(n,r){return function(){for(var e=[],u=0;u<arguments.length;u++)e[u]=arguments[u];return t(n,(function(){return r.apply(void 0,e)}))}},run:t,use:i,useX:function(n){var t;return null!==(t=c.ctx)&&void 0!==t?t:u(e(n,"Context was used after it was closed"))}}}((function(n,t){var r={value:n.value,meta:n.meta||{}};return t?n.set?o(r,{parent:function(){return function(n){return n?{value:n.value,meta:n.meta,parent:n.parent}:n}(t)}}):t:o(r,{parent:c})}));function c(){return null}function f(n,t){return n.length===Number(t)}function a(n){if(n){if(function(n){return"number"==typeof n}(n))return 0===n;if(function(n,t){return Object.prototype.hasOwnProperty.call(n,t)}(n,"length"))return f(n,0);if("object"==typeof n)return f(Object.keys(n),0)}return!0}function s(n,t){return n={pass:n},t&&(n.message=t),n}function l(n){return e(n,s(!0))}function v(n,t){try{return n.run(t)}catch(n){return s(!1)}}module.exports=function(){function t(t){return i.run({value:t},(function(){return l(n(r,(function(n,r){(n=v(n,t)).pass||r(n)})))}))}for(var r=[],e=0;e<arguments.length;e++)r[e]=arguments[e];return Object.assign((function(n){if(!(n=t(n)).pass){if(!a(n.message))throw n.message;u()}}),{run:t,test:function(n){return t(n).pass}})};