n4s 5.0.0-dev-781e21 → 5.0.0-dev-ae6b14

package/dist/umd/schema.development.js

@@ -1,11 +1,11 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('n4s'), require('vest-utils')) :
   typeof define === 'function' && define.amd ? define(['exports', 'n4s', 'vest-utils'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.schema = {}, global.n4s, global['vest-utils']));
-}(this, (function (exports, n4s, vestUtils) { 'use strict';
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.schema = {}, global.n4s, global["vest-utils"]));
+})(this, (function (exports, n4s, vestUtils) { 'use strict';
 
   function ruleReturn(pass, message) {
-      var output = { pass: pass };
+      const output = { pass };
       if (message) {
           output.message = message;
       }
@@ -31,27 +31,20 @@
   }
 
   function isArrayOf(inputArray, currentRule) {
-      return defaultToPassing(vestUtils.mapFirst(inputArray, function (currentValue, breakout, index) {
-          var res = n4s.ctx.run({ value: currentValue, set: true, meta: { index: index } }, function () { return runLazyRule(currentRule, currentValue); });
+      return defaultToPassing(vestUtils.mapFirst(inputArray, (currentValue, breakout, index) => {
+          const res = n4s.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 = n4s.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 = n4s.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();
   }
@@ -64,11 +57,11 @@
   }
 
   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 (!vestUtils.hasOwnProperty(shapeObject, key)) {
               return failing();
           }
@@ -79,17 +72,15 @@
   // 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] = n4s.enforce.optional(shapeObject[key]);
       }
       return output;
   }
 
-  n4s.enforce.extend({ isArrayOf: isArrayOf, loose: loose, optional: optional, shape: shape });
+  n4s.enforce.extend({ isArrayOf, loose, optional, shape });
 
   exports.partial = partial;
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-})));
+}));

package/dist/umd/schema.production.js

@@ -1 +1 @@
-"use strict";!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports,require("n4s"),require("vest-utils")):"function"==typeof define&&define.amd?define(["exports","n4s","vest-utils"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).schema={},e.n4s,e["vest-utils"])}(this,(function(e,n,t){function r(e,n){return e={pass:e},n&&(e.message=n),e}function u(e,n){try{return e.run(n)}catch(e){return r(!1)}}function i(e,t){var i,o=function(r){var i=e[r],o=t[r];if(!(r=n.ctx.run({value:i,set:!0,meta:{key:r}},(function(){return u(o,i)}))).pass)return{value:r}};for(i in t){var s=o(i);if("object"==typeof s)return s.value}return r(!0)}n.enforce.extend({isArrayOf:function(e,i){return t.defaultTo(t.mapFirst(e,(function(e,t,r){t(!(r=n.ctx.run({value:e,set:!0,meta:{index:r}},(function(){return u(i,e)}))).pass,r)})),r(!0))},loose:i,optional:function(e,n){return t.isNullish(e)?r(!0):u(n,e)},shape:function(e,n){var u=i(e,n);if(!u.pass)return u;for(var o in e)if(!t.hasOwnProperty(n,o))return r(!1);return r(!0)}}),e.partial=function(e){var t,r={};for(t in e)r[t]=n.enforce.optional(e[t]);return r},Object.defineProperty(e,"__esModule",{value:!0})}));
+!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("n4s"),require("vest-utils")):"function"==typeof define&&define.amd?define(["exports","n4s","vest-utils"],t):t((n="undefined"!=typeof globalThis?globalThis:n||self).schema={},n.n4s,n["vest-utils"])}(this,(function(n,t,e){"use strict";function r(n,t){const e={pass:n};return t&&(e.message=t),e}function s(){return r(!1)}function o(){return r(!0)}function u(n,t){try{return n.run(t)}catch(n){return s()}}function i(n,e){for(const r in e){const s=n[r],o=e[r],i=t.ctx.run({value:s,set:!0,meta:{key:r}},(()=>u(o,s)));if(!i.pass)return i}return o()}t.enforce.extend({isArrayOf:function(n,r){return s=e.mapFirst(n,((n,e,s)=>{const o=t.ctx.run({value:n,set:!0,meta:{index:s}},(()=>u(r,n)));e(!o.pass,o)})),e.defaultTo(s,o());var s},loose:i,optional:function(n,t){return e.isNullish(n)?o():u(t,n)},shape:function(n,t){const r=i(n,t);if(!r.pass)return r;for(const r in n)if(!e.hasOwnProperty(t,r))return s();return o()}}),n.partial=function(n){const e={};for(const r in n)e[r]=t.enforce.optional(n[r]);return e}}));

package/package.json

@@ -1,49 +1,56 @@
 {
-  "version": "5.0.0-dev-781e21",
+  "version": "5.0.0-dev-ae6b14",
   "license": "MIT",
   "main": "./dist/cjs/n4s.js",
   "types": "./types/n4s.d.ts",
   "name": "n4s",
   "author": "ealush",
+  "description": "Assertion library for form validations",
+  "keywords": [
+    "vest",
+    "enforce",
+    "n4s",
+    "validation"
+  ],
   "scripts": {
     "test": "vx test",
     "release": "vx release"
   },
   "dependencies": {
-    "context": "^3.0.0-dev-781e21",
-    "vest-utils": "^0.0.2"
+    "context": "3.0.9-dev-ae6b14",
+    "vest-utils": "1.0.0-dev-ae6b14"
   },
   "module": "./dist/es/n4s.production.js",
   "exports": {
-    "./compose": {
+    "./schema": {
       "production": {
-        "types": "./types/compose.d.ts",
-        "browser": "./dist/es/compose.production.js",
-        "umd": "./dist/umd/compose.production.js",
-        "import": "./dist/es/compose.production.js",
-        "require": "./dist/cjs/compose.production.js",
-        "node": "./dist/cjs/compose.production.js",
-        "module": "./dist/es/compose.production.js",
-        "default": "./dist/cjs/compose.production.js"
+        "types": "./types/schema.d.ts",
+        "browser": "./dist/es/schema.production.js",
+        "umd": "./dist/umd/schema.production.js",
+        "import": "./dist/es/schema.production.js",
+        "require": "./dist/cjs/schema.production.js",
+        "node": "./dist/cjs/schema.production.js",
+        "module": "./dist/es/schema.production.js",
+        "default": "./dist/cjs/schema.production.js"
       },
       "development": {
-        "types": "./types/compose.d.ts",
-        "browser": "./dist/es/compose.development.js",
-        "umd": "./dist/umd/compose.development.js",
-        "import": "./dist/es/compose.development.js",
-        "require": "./dist/cjs/compose.development.js",
-        "node": "./dist/cjs/compose.development.js",
-        "module": "./dist/es/compose.development.js",
-        "default": "./dist/cjs/compose.development.js"
+        "types": "./types/schema.d.ts",
+        "browser": "./dist/es/schema.development.js",
+        "umd": "./dist/umd/schema.development.js",
+        "import": "./dist/es/schema.development.js",
+        "require": "./dist/cjs/schema.development.js",
+        "node": "./dist/cjs/schema.development.js",
+        "module": "./dist/es/schema.development.js",
+        "default": "./dist/cjs/schema.development.js"
       },
-      "types": "./types/compose.d.ts",
-      "browser": "./dist/es/compose.production.js",
-      "umd": "./dist/umd/compose.production.js",
-      "import": "./dist/es/compose.production.js",
-      "require": "./dist/cjs/compose.production.js",
-      "node": "./dist/cjs/compose.production.js",
-      "module": "./dist/es/compose.production.js",
-      "default": "./dist/cjs/compose.production.js"
+      "types": "./types/schema.d.ts",
+      "browser": "./dist/es/schema.production.js",
+      "umd": "./dist/umd/schema.production.js",
+      "import": "./dist/es/schema.production.js",
+      "require": "./dist/cjs/schema.production.js",
+      "node": "./dist/cjs/schema.production.js",
+      "module": "./dist/es/schema.production.js",
+      "default": "./dist/cjs/schema.production.js"
     },
     "./compounds": {
       "production": {
@@ -75,35 +82,35 @@
       "module": "./dist/es/compounds.production.js",
       "default": "./dist/cjs/compounds.production.js"
     },
-    "./schema": {
+    "./compose": {
       "production": {
-        "types": "./types/schema.d.ts",
-        "browser": "./dist/es/schema.production.js",
-        "umd": "./dist/umd/schema.production.js",
-        "import": "./dist/es/schema.production.js",
-        "require": "./dist/cjs/schema.production.js",
-        "node": "./dist/cjs/schema.production.js",
-        "module": "./dist/es/schema.production.js",
-        "default": "./dist/cjs/schema.production.js"
+        "types": "./types/compose.d.ts",
+        "browser": "./dist/es/compose.production.js",
+        "umd": "./dist/umd/compose.production.js",
+        "import": "./dist/es/compose.production.js",
+        "require": "./dist/cjs/compose.production.js",
+        "node": "./dist/cjs/compose.production.js",
+        "module": "./dist/es/compose.production.js",
+        "default": "./dist/cjs/compose.production.js"
       },
       "development": {
-        "types": "./types/schema.d.ts",
-        "browser": "./dist/es/schema.development.js",
-        "umd": "./dist/umd/schema.development.js",
-        "import": "./dist/es/schema.development.js",
-        "require": "./dist/cjs/schema.development.js",
-        "node": "./dist/cjs/schema.development.js",
-        "module": "./dist/es/schema.development.js",
-        "default": "./dist/cjs/schema.development.js"
+        "types": "./types/compose.d.ts",
+        "browser": "./dist/es/compose.development.js",
+        "umd": "./dist/umd/compose.development.js",
+        "import": "./dist/es/compose.development.js",
+        "require": "./dist/cjs/compose.development.js",
+        "node": "./dist/cjs/compose.development.js",
+        "module": "./dist/es/compose.development.js",
+        "default": "./dist/cjs/compose.development.js"
       },
-      "types": "./types/schema.d.ts",
-      "browser": "./dist/es/schema.production.js",
-      "umd": "./dist/umd/schema.production.js",
-      "import": "./dist/es/schema.production.js",
-      "require": "./dist/cjs/schema.production.js",
-      "node": "./dist/cjs/schema.production.js",
-      "module": "./dist/es/schema.production.js",
-      "default": "./dist/cjs/schema.production.js"
+      "types": "./types/compose.d.ts",
+      "browser": "./dist/es/compose.production.js",
+      "umd": "./dist/umd/compose.production.js",
+      "import": "./dist/es/compose.production.js",
+      "require": "./dist/cjs/compose.production.js",
+      "node": "./dist/cjs/compose.production.js",
+      "module": "./dist/es/compose.production.js",
+      "default": "./dist/cjs/compose.production.js"
     },
     ".": {
       "development": {
@@ -126,7 +133,7 @@
       "default": "./dist/cjs/n4s.production.js"
     },
     "./package.json": "./package.json",
-    "./": "./"
+    "./*": "./*"
   },
   "repository": {
     "type": "git",
@@ -138,4 +145,4 @@
   },
   "unpkg": "./dist/umd/n4s.production.js",
   "jsdelivr": "./dist/umd/n4s.production.js"
-}
+}

package/testUtils/TEnforceMock.ts

@@ -0,0 +1,3 @@
+import { enforce } from 'n4s';
+
+export type TEnforceMock = typeof enforce;

package/types/compose.d.ts

@@ -1,9 +1,4 @@
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type Stringable = string | ((...args: any[]) => string);
-type CB = (...args: any[]) => any;
+import { CB, Stringable, DropFirst } from "vest-utils";
 type RuleReturn = boolean | {
     pass: boolean;
     message?: Stringable;
@@ -41,16 +36,16 @@ declare const baseRules: {
     doesNotStartWith: (value: string, arg1: string) => boolean;
     endsWith: typeof endsWith;
     equals: typeof equals;
-    greaterThan: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    greaterThan: typeof import("vest-utils").greaterThan;
     greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    gt: typeof import("vest-utils").greaterThan;
     gte: typeof greaterThanOrEquals;
     inside: typeof inside;
-    isArray: typeof import("packages/vest-utils/types/vest-utils").isArray;
+    isArray: typeof import("vest-utils").isArray;
     isBetween: typeof isBetween;
     isBlank: typeof isBlank;
-    isBoolean: typeof import("packages/vest-utils/types/vest-utils").isBoolean;
-    isEmpty: typeof import("packages/vest-utils/types/vest-utils").isEmpty;
+    isBoolean: typeof import("vest-utils").isBoolean;
+    isEmpty: typeof import("vest-utils").isEmpty;
     isEven: (value: any) => boolean;
     isFalsy: (value: unknown) => boolean;
     isKeyOf: typeof isKeyOf;
@@ -70,21 +65,21 @@ declare const baseRules: {
     isNotString: (v: unknown) => boolean;
     isNotUndefined: (value?: unknown) => boolean;
     isNotValueOf: (value: any, objectToCheck: any) => boolean;
-    isNull: typeof import("packages/vest-utils/types/vest-utils").isNull;
-    isNullish: typeof import("packages/vest-utils/types/vest-utils").isNullish;
+    isNull: typeof import("vest-utils").isNull;
+    isNullish: typeof import("vest-utils").isNullish;
     isNumber: typeof isNumber;
-    isNumeric: typeof import("packages/vest-utils/types/vest-utils").isNumeric;
+    isNumeric: typeof import("vest-utils").isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: typeof import("packages/vest-utils/types/vest-utils").isPositive;
-    isString: typeof import("packages/vest-utils/types/vest-utils").isStringValue;
+    isPositive: typeof import("vest-utils").isPositive;
+    isString: typeof import("vest-utils").isStringValue;
     isTruthy: typeof isTruthy;
-    isUndefined: typeof import("packages/vest-utils/types/vest-utils").isUndefined;
+    isUndefined: typeof import("vest-utils").isUndefined;
     isValueOf: typeof isValueOf;
-    lengthEquals: typeof import("packages/vest-utils/types/vest-utils").lengthEquals;
+    lengthEquals: typeof import("vest-utils").lengthEquals;
     lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
     lessThan: typeof lessThan;
     lessThanOrEquals: typeof lessThanOrEquals;
-    longerThan: typeof import("packages/vest-utils/types/vest-utils").longerThan;
+    longerThan: typeof import("vest-utils").longerThan;
     longerThanOrEquals: typeof longerThanOrEquals;
     lt: typeof lessThan;
     lte: typeof lessThanOrEquals;
@@ -92,13 +87,13 @@ declare const baseRules: {
     notEquals: (value: unknown, arg1: unknown) => boolean;
     notInside: (value: unknown, arg1: string | unknown[]) => boolean;
     notMatches: (value: string, regex: string | RegExp) => boolean;
-    numberEquals: typeof import("packages/vest-utils/types/vest-utils").numberEquals;
+    numberEquals: typeof import("vest-utils").numberEquals;
     numberNotEquals: (value: string | number, eq: string | number) => boolean;
     shorterThan: typeof shorterThan;
     shorterThanOrEquals: typeof shorterThanOrEquals;
     startsWith: typeof startsWith;
 };
-type Rules<E> = n4s.EnforceCustomMatchers<Rules<E> & E> & Record<string, (...args: Args) => Rules<E> & E> & {
+type Rules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<Rules<E> & E> & Record<string, (...args: Args) => Rules<E> & E> & {
     [P in KBaseRules]: (...args: DropFirst<Parameters<BaseRules[P]>> | Args) => Rules<E> & E;
 };
 /* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
@@ -124,3 +119,4 @@ type ComposeResult = LazyRuleRunners & ((value: any) => void);
 type LazyMessage = string | ((value: unknown, originalMessage?: Stringable) => string);
 declare function compose(...composites: LazyRuleRunners[]): ComposeResult;
 export { compose as default };
+//# sourceMappingURL=compose.d.ts.map

package/types/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/exports/compose.ts","../src/runtime/enforceContext.ts","../src/lib/ruleReturn.ts","../src/rules/endsWith.ts","../src/rules/equals.ts","../src/rules/greaterThanOrEquals.ts","../src/rules/inside.ts","../src/rules/lessThan.ts","../src/rules/lessThanOrEquals.ts","../src/rules/isBetween.ts","../src/rules/isBlank.ts","../src/rules/isBoolean.ts","../src/rules/isEven.ts","../src/rules/isKeyOf.ts","../src/rules/isNaN.ts","../src/rules/isNegative.ts","../src/rules/isNumber.ts","../src/rules/isOdd.ts","../src/rules/isString.ts","../src/rules/isTruthy.ts","../src/rules/isValueOf.ts","../src/rules/longerThanOrEquals.ts","../src/rules/matches.ts","../src/rules/ruleCondition.ts","../src/rules/shorterThan.ts","../src/rules/shorterThanOrEquals.ts","../src/rules/startsWith.ts","../src/runtime/rules.ts","../src/runtime/runtimeRules.ts","../src/lib/transformResult.ts","../src/runtime/genEnforceLazy.ts","../src/lib/runLazyRule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,iBAAwB,OAAO,CAC7B,GAAG,UAAU,EAAE,eAAe,EAAE,GAC/B,aAAa,CAoCf"}

package/types/compounds.d.ts

@@ -1,9 +1,4 @@
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type Stringable = string | ((...args: any[]) => string);
-type CB = (...args: any[]) => any;
+import { CB, DropFirst, Stringable } from "vest-utils";
 type EnforceCustomMatcher<F extends CB, R> = (...args: DropFirst<Parameters<F>>) => R;
 type RuleReturn = boolean | {
     pass: boolean;
@@ -42,16 +37,16 @@ declare const baseRules: {
     doesNotStartWith: (value: string, arg1: string) => boolean;
     endsWith: typeof endsWith;
     equals: typeof equals;
-    greaterThan: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    greaterThan: typeof import("vest-utils").greaterThan;
     greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    gt: typeof import("vest-utils").greaterThan;
     gte: typeof greaterThanOrEquals;
     inside: typeof inside;
-    isArray: typeof import("packages/vest-utils/types/vest-utils").isArray;
+    isArray: typeof import("vest-utils").isArray;
     isBetween: typeof isBetween;
     isBlank: typeof isBlank;
-    isBoolean: typeof import("packages/vest-utils/types/vest-utils").isBoolean;
-    isEmpty: typeof import("packages/vest-utils/types/vest-utils").isEmpty;
+    isBoolean: typeof import("vest-utils").isBoolean;
+    isEmpty: typeof import("vest-utils").isEmpty;
     isEven: (value: any) => boolean;
     isFalsy: (value: unknown) => boolean;
     isKeyOf: typeof isKeyOf;
@@ -71,21 +66,21 @@ declare const baseRules: {
     isNotString: (v: unknown) => boolean;
     isNotUndefined: (value?: unknown) => boolean;
     isNotValueOf: (value: any, objectToCheck: any) => boolean;
-    isNull: typeof import("packages/vest-utils/types/vest-utils").isNull;
-    isNullish: typeof import("packages/vest-utils/types/vest-utils").isNullish;
+    isNull: typeof import("vest-utils").isNull;
+    isNullish: typeof import("vest-utils").isNullish;
     isNumber: typeof isNumber;
-    isNumeric: typeof import("packages/vest-utils/types/vest-utils").isNumeric;
+    isNumeric: typeof import("vest-utils").isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: typeof import("packages/vest-utils/types/vest-utils").isPositive;
-    isString: typeof import("packages/vest-utils/types/vest-utils").isStringValue;
+    isPositive: typeof import("vest-utils").isPositive;
+    isString: typeof import("vest-utils").isStringValue;
     isTruthy: typeof isTruthy;
-    isUndefined: typeof import("packages/vest-utils/types/vest-utils").isUndefined;
+    isUndefined: typeof import("vest-utils").isUndefined;
     isValueOf: typeof isValueOf;
-    lengthEquals: typeof import("packages/vest-utils/types/vest-utils").lengthEquals;
+    lengthEquals: typeof import("vest-utils").lengthEquals;
     lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
     lessThan: typeof lessThan;
     lessThanOrEquals: typeof lessThanOrEquals;
-    longerThan: typeof import("packages/vest-utils/types/vest-utils").longerThan;
+    longerThan: typeof import("vest-utils").longerThan;
     longerThanOrEquals: typeof longerThanOrEquals;
     lt: typeof lessThan;
     lte: typeof lessThanOrEquals;
@@ -93,13 +88,13 @@ declare const baseRules: {
     notEquals: (value: unknown, arg1: unknown) => boolean;
     notInside: (value: unknown, arg1: string | unknown[]) => boolean;
     notMatches: (value: string, regex: string | RegExp) => boolean;
-    numberEquals: typeof import("packages/vest-utils/types/vest-utils").numberEquals;
+    numberEquals: typeof import("vest-utils").numberEquals;
     numberNotEquals: (value: string | number, eq: string | number) => boolean;
     shorterThan: typeof shorterThan;
     shorterThanOrEquals: typeof shorterThanOrEquals;
     startsWith: typeof startsWith;
 };
-type Rules<E> = n4s.EnforceCustomMatchers<Rules<E> & E> & Record<string, (...args: Args) => Rules<E> & E> & {
+type Rules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<Rules<E> & E> & Record<string, (...args: Args) => Rules<E> & E> & {
     [P in KBaseRules]: (...args: DropFirst<Parameters<BaseRules[P]>> | Args) => Rules<E> & E;
 };
 /* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
@@ -133,4 +128,4 @@ declare global {
         }
     }
 }
-export {};
+//# sourceMappingURL=compounds.d.ts.map

package/types/compounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compounds.d.ts","sourceRoot":"","sources":["../src/exports/compounds.ts","../src/runtime/enforceContext.ts","../src/lib/ruleReturn.ts","../src/rules/endsWith.ts","../src/rules/equals.ts","../src/rules/greaterThanOrEquals.ts","../src/rules/inside.ts","../src/rules/lessThan.ts","../src/rules/lessThanOrEquals.ts","../src/rules/isBetween.ts","../src/rules/isBlank.ts","../src/rules/isBoolean.ts","../src/rules/isEven.ts","../src/rules/isKeyOf.ts","../src/rules/isNaN.ts","../src/rules/isNegative.ts","../src/rules/isNumber.ts","../src/rules/isOdd.ts","../src/rules/isString.ts","../src/rules/isTruthy.ts","../src/rules/isValueOf.ts","../src/rules/longerThanOrEquals.ts","../src/rules/matches.ts","../src/rules/ruleCondition.ts","../src/rules/shorterThan.ts","../src/rules/shorterThanOrEquals.ts","../src/rules/startsWith.ts","../src/runtime/rules.ts","../src/runtime/runtimeRules.ts","../src/lib/transformResult.ts","../src/runtime/genEnforceLazy.ts","../src/lib/runLazyRule.ts","../src/plugins/compounds/allOf.ts","../src/plugins/compounds/anyOf.ts","../src/lib/enforceUtilityTypes.ts","../src/plugins/compounds/noneOf.ts","../src/plugins/compounds/oneOf.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,KAAK,mBAAmB,GAAG,CACzB,KAAK,EAAE,OAAO,EACd,GAAG,KAAK,EAAE,IAAI,EAAE,KACb,kBAAkB,CAAC;AAGxB,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;YAC/B,KAAK,EAAE,oBAAoB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;YACpD,KAAK,EAAE,oBAAoB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;YACpD,MAAM,EAAE,oBAAoB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;YACrD,KAAK,EAAE,oBAAoB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;SACrD;KACF;CACF"}

package/types/n4s.d.ts

@@ -1,3 +1,4 @@
+import { DropFirst, Stringable, CB } from "vest-utils";
 declare const ctx: import("context").CtxCascadeApi<CTXType>;
 type CTXType = {
     meta: Record<string, any>;
@@ -10,12 +11,6 @@ type EnforceContext = null | {
     value: any;
     parent: () => EnforceContext;
 };
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type Stringable = string | ((...args: any[]) => string);
-type CB = (...args: any[]) => any;
 type RuleReturn = boolean | {
     pass: boolean;
     message?: Stringable;
@@ -56,16 +51,16 @@ declare const baseRules: {
     doesNotStartWith: (value: string, arg1: string) => boolean;
     endsWith: typeof endsWith;
     equals: typeof equals;
-    greaterThan: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    greaterThan: typeof import("vest-utils").greaterThan;
     greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof import("packages/vest-utils/types/vest-utils").greaterThan;
+    gt: typeof import("vest-utils").greaterThan;
     gte: typeof greaterThanOrEquals;
     inside: typeof inside;
-    isArray: typeof import("packages/vest-utils/types/vest-utils").isArray;
+    isArray: typeof import("vest-utils").isArray;
     isBetween: typeof isBetween;
     isBlank: typeof isBlank;
-    isBoolean: typeof import("packages/vest-utils/types/vest-utils").isBoolean;
-    isEmpty: typeof import("packages/vest-utils/types/vest-utils").isEmpty;
+    isBoolean: typeof import("vest-utils").isBoolean;
+    isEmpty: typeof import("vest-utils").isEmpty;
     isEven: (value: any) => boolean;
     isFalsy: (value: unknown) => boolean;
     isKeyOf: typeof isKeyOf;
@@ -85,21 +80,21 @@ declare const baseRules: {
     isNotString: (v: unknown) => boolean;
     isNotUndefined: (value?: unknown) => boolean;
     isNotValueOf: (value: any, objectToCheck: any) => boolean;
-    isNull: typeof import("packages/vest-utils/types/vest-utils").isNull;
-    isNullish: typeof import("packages/vest-utils/types/vest-utils").isNullish;
+    isNull: typeof import("vest-utils").isNull;
+    isNullish: typeof import("vest-utils").isNullish;
     isNumber: typeof isNumber;
-    isNumeric: typeof import("packages/vest-utils/types/vest-utils").isNumeric;
+    isNumeric: typeof import("vest-utils").isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: typeof import("packages/vest-utils/types/vest-utils").isPositive;
-    isString: typeof import("packages/vest-utils/types/vest-utils").isStringValue;
+    isPositive: typeof import("vest-utils").isPositive;
+    isString: typeof import("vest-utils").isStringValue;
     isTruthy: typeof isTruthy;
-    isUndefined: typeof import("packages/vest-utils/types/vest-utils").isUndefined;
+    isUndefined: typeof import("vest-utils").isUndefined;
     isValueOf: typeof isValueOf;
-    lengthEquals: typeof import("packages/vest-utils/types/vest-utils").lengthEquals;
+    lengthEquals: typeof import("vest-utils").lengthEquals;
     lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
     lessThan: typeof lessThan;
     lessThanOrEquals: typeof lessThanOrEquals;
-    longerThan: typeof import("packages/vest-utils/types/vest-utils").longerThan;
+    longerThan: typeof import("vest-utils").longerThan;
     longerThanOrEquals: typeof longerThanOrEquals;
     lt: typeof lessThan;
     lte: typeof lessThanOrEquals;
@@ -107,13 +102,13 @@ declare const baseRules: {
     notEquals: (value: unknown, arg1: unknown) => boolean;
     notInside: (value: unknown, arg1: string | unknown[]) => boolean;
     notMatches: (value: string, regex: string | RegExp) => boolean;
-    numberEquals: typeof import("packages/vest-utils/types/vest-utils").numberEquals;
+    numberEquals: typeof import("vest-utils").numberEquals;
     numberNotEquals: (value: string | number, eq: string | number) => boolean;
     shorterThan: typeof shorterThan;
     shorterThanOrEquals: typeof shorterThanOrEquals;
     startsWith: typeof startsWith;
 };
-type Rules<E> = n4s.EnforceCustomMatchers<Rules<E> & E> & Record<string, (...args: Args) => Rules<E> & E> & {
+type Rules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<Rules<E> & E> & Record<string, (...args: Args) => Rules<E> & E> & {
     [P in KBaseRules]: (...args: DropFirst<Parameters<BaseRules[P]>> | Args) => Rules<E> & E;
 };
 /* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
@@ -124,7 +119,11 @@ declare global {
     }
 }
 type IRules = n4s.IRules<Record<string, any>>;
-type EnforceEager = (value: RuleValue) => IRules;
+type TModifiers = {
+    message: (input: string) => EnforceEagerReturn;
+};
+type EnforceEagerReturn = IRules & TModifiers;
+type EnforceEager = (value: RuleValue) => EnforceEagerReturn;
 type LazyRules = n4s.IRules<LazyRuleMethods>;
 type Lazy = LazyRules & LazyRuleMethods & 
 // This is a "catch all" hack to make TS happy while not
@@ -151,3 +150,4 @@ declare global {
     }
 }
 export { enforce, ctx };
+//# sourceMappingURL=n4s.d.ts.map

package/types/n4s.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n4s.d.ts","sourceRoot":"","sources":["../src/n4s.ts","../src/runtime/enforceContext.ts","../src/lib/ruleReturn.ts","../src/rules/endsWith.ts","../src/rules/equals.ts","../src/rules/greaterThanOrEquals.ts","../src/rules/inside.ts","../src/rules/lessThan.ts","../src/rules/lessThanOrEquals.ts","../src/rules/isBetween.ts","../src/rules/isBlank.ts","../src/rules/isBoolean.ts","../src/rules/isEven.ts","../src/rules/isKeyOf.ts","../src/rules/isNaN.ts","../src/rules/isNegative.ts","../src/rules/isNumber.ts","../src/rules/isOdd.ts","../src/rules/isString.ts","../src/rules/isTruthy.ts","../src/rules/isValueOf.ts","../src/rules/longerThanOrEquals.ts","../src/rules/matches.ts","../src/rules/ruleCondition.ts","../src/rules/shorterThan.ts","../src/rules/shorterThanOrEquals.ts","../src/rules/startsWith.ts","../src/runtime/rules.ts","../src/runtime/runtimeRules.ts","../src/lib/transformResult.ts","../src/runtime/enforceEager.ts","../src/runtime/genEnforceLazy.ts","../src/runtime/enforce.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;SAAI;KACtC;CACF;AARD,OAAO,gBAAW,CAAgB"}