n4s 4.1.9 → 4.2.2-dev-fcaa09

package/dist/umd/schema.development.js

@@ -1,61 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('n4s')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'n4s'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.schema = {}, global.n4s));
-}(this, (function (exports, n4s) { 'use strict';
-
-  function isNull(value) {
-      return value === null;
-  }
-
-  function isUndefined(value) {
-      return value === undefined;
-  }
-
-  function isNullish(value) {
-      return isNull(value) || isUndefined(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(value, defaultValue) {
-      var _a;
-      return (_a = optionalFunctionValue(value)) !== null && _a !== void 0 ? _a : optionalFunctionValue(defaultValue);
-  }
-
-  /**
-   * A safe hasOwnProperty access
-   */
-  function hasOwnProperty(obj, key) {
-      return Object.prototype.hasOwnProperty.call(obj, key);
-  }
-
-  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(conditional, value) {
-          if (conditional) {
-              broke = true;
-              breakoutValue = value;
-          }
-      }
-  }
+  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';
 
   function ruleReturn(pass, message) {
       var output = { pass: pass };
@@ -71,7 +18,7 @@
       return ruleReturn(true);
   }
   function defaultToPassing(callback) {
-      return defaultTo(callback, passing());
+      return vestUtils.defaultTo(callback, passing());
   }
 
   function runLazyRule(lazyRule, currentValue) {
@@ -84,7 +31,7 @@
   }
 
   function isArrayOf(inputArray, currentRule) {
-      return defaultToPassing(mapFirst(inputArray, function (currentValue, breakout, index) {
+      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); });
           breakout(!res.pass, res);
       }));
@@ -110,7 +57,7 @@
   }
 
   function optional(value, ruleChain) {
-      if (isNullish(value)) {
+      if (vestUtils.isNullish(value)) {
           return passing();
       }
       return runLazyRule(ruleChain, value);
@@ -122,7 +69,7 @@
           return baseRes;
       }
       for (var key in inputObject) {
-          if (!hasOwnProperty(shapeObject, key)) {
+          if (!vestUtils.hasOwnProperty(shapeObject, key)) {
               return failing();
           }
       }

package/dist/umd/schema.production.js

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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.1.9",
+  "version": "4.2.2-dev-fcaa09",
   "license": "MIT",
   "main": "./dist/cjs/n4s.js",
   "types": "./types/n4s.d.ts",
@@ -10,8 +10,8 @@
     "release": "vx release"
   },
   "dependencies": {
-    "context": "^2.0.8",
-    "vest-utils": "^0.0.2"
+    "context": "^3.0.2-dev-fcaa09",
+    "vest-utils": "^0.0.3-dev-fcaa09"
   },
   "module": "./dist/es/n4s.production.js",
   "exports": {

package/tsconfig.json

@@ -1,8 +1,62 @@
 {
   "extends": "../../tsconfig.json",
+  "rootDir": ".",
   "compilerOptions": {
+    "baseUrl": ".",
     "declarationMap": true,
     "declarationDir": "./types",
-    "outDir": "./dist"
+    "outDir": "./dist",
+    "paths": {
+      "compose": ["src/exports/compose.ts"],
+      "compounds": ["src/exports/compounds.ts"],
+      "schema": ["src/exports/schema.ts"],
+      "eachEnforceRule": ["src/lib/eachEnforceRule.ts"],
+      "enforceUtilityTypes": ["src/lib/enforceUtilityTypes.ts"],
+      "isProxySupported": ["src/lib/isProxySupported.ts"],
+      "ruleReturn": ["src/lib/ruleReturn.ts"],
+      "runLazyRule": ["src/lib/runLazyRule.ts"],
+      "transformResult": ["src/lib/transformResult.ts"],
+      "n4s": ["src/n4s.ts"],
+      "allOf": ["src/plugins/compounds/allOf.ts"],
+      "anyOf": ["src/plugins/compounds/anyOf.ts"],
+      "noneOf": ["src/plugins/compounds/noneOf.ts"],
+      "oneOf": ["src/plugins/compounds/oneOf.ts"],
+      "isArrayOf": ["src/plugins/schema/isArrayOf.ts"],
+      "loose": ["src/plugins/schema/loose.ts"],
+      "optional": ["src/plugins/schema/optional.ts"],
+      "partial": ["src/plugins/schema/partial.ts"],
+      "schemaTypes": ["src/plugins/schema/schemaTypes.ts"],
+      "shape": ["src/plugins/schema/shape.ts"],
+      "endsWith": ["src/rules/endsWith.ts"],
+      "equals": ["src/rules/equals.ts"],
+      "greaterThanOrEquals": ["src/rules/greaterThanOrEquals.ts"],
+      "inside": ["src/rules/inside.ts"],
+      "isBetween": ["src/rules/isBetween.ts"],
+      "isBlank": ["src/rules/isBlank.ts"],
+      "isBoolean": ["src/rules/isBoolean.ts"],
+      "isEven": ["src/rules/isEven.ts"],
+      "isKeyOf": ["src/rules/isKeyOf.ts"],
+      "isNaN": ["src/rules/isNaN.ts"],
+      "isNegative": ["src/rules/isNegative.ts"],
+      "isNumber": ["src/rules/isNumber.ts"],
+      "isOdd": ["src/rules/isOdd.ts"],
+      "isString": ["src/rules/isString.ts"],
+      "isTruthy": ["src/rules/isTruthy.ts"],
+      "isValueOf": ["src/rules/isValueOf.ts"],
+      "lessThan": ["src/rules/lessThan.ts"],
+      "lessThanOrEquals": ["src/rules/lessThanOrEquals.ts"],
+      "longerThanOrEquals": ["src/rules/longerThanOrEquals.ts"],
+      "matches": ["src/rules/matches.ts"],
+      "ruleCondition": ["src/rules/ruleCondition.ts"],
+      "shorterThan": ["src/rules/shorterThan.ts"],
+      "shorterThanOrEquals": ["src/rules/shorterThanOrEquals.ts"],
+      "startsWith": ["src/rules/startsWith.ts"],
+      "enforce": ["src/runtime/enforce.ts"],
+      "enforceContext": ["src/runtime/enforceContext.ts"],
+      "enforceEager": ["src/runtime/enforceEager.ts"],
+      "genEnforceLazy": ["src/runtime/genEnforceLazy.ts"],
+      "rules": ["src/runtime/rules.ts"],
+      "runtimeRules": ["src/runtime/runtimeRules.ts"]
+    }
   }
 }

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,7 +87,7 @@ 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;
@@ -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/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/eachEnforceRule.ts","../src/runtime/enforceContext.ts","../src/lib/isProxySupported.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,5 @@
-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;
     message?: Stringable;
@@ -41,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;
@@ -70,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;
@@ -92,7 +88,7 @@ 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;
@@ -121,18 +117,15 @@ type LazyRuleRunners = {
     run: (value: unknown) => RuleDetailedResult;
 };
 type LazyMessage = string | ((value: unknown, originalMessage?: Stringable) => string);
-declare function allOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult;
-declare function anyOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult;
-declare function noneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult;
-declare function oneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult;
+type EnforceCompoundRule = (value: unknown, ...rules: Lazy[]) => RuleDetailedResult;
 declare global {
     namespace n4s {
         interface EnforceCustomMatchers<R> {
-            allOf: (...args: DropFirst<Parameters<typeof allOf>>) => R;
-            anyOf: (...args: DropFirst<Parameters<typeof anyOf>>) => R;
-            noneOf: (...args: DropFirst<Parameters<typeof noneOf>>) => R;
-            oneOf: (...args: DropFirst<Parameters<typeof oneOf>>) => R;
+            allOf: EnforceCustomMatcher<EnforceCompoundRule, R>;
+            anyOf: EnforceCustomMatcher<EnforceCompoundRule, R>;
+            noneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;
+            oneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;
         }
     }
 }
-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/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/eachEnforceRule.ts","../src/runtime/enforceContext.ts","../src/lib/isProxySupported.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,9 +1,5 @@
-declare const ctx: {
-    run: <R>(ctxRef: Partial<CTXType>, fn: (context: CTXType) => R) => R;
-    bind: <Fn extends (...args: any[]) => any>(ctxRef: Partial<CTXType>, fn: Fn) => Fn;
-    use: () => CTXType | undefined;
-    useX: (errorMessage?: string | undefined) => CTXType;
-};
+import { Stringable, DropFirst, CB } from "vest-utils";
+declare const ctx: import("context").CtxCascadeApi<CTXType>;
 type CTXType = {
     meta: Record<string, any>;
     value: any;
@@ -15,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;
@@ -61,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;
@@ -90,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;
@@ -112,7 +102,7 @@ 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;
@@ -129,8 +119,7 @@ declare global {
     }
 }
 type IRules = n4s.IRules<Record<string, any>>;
-declare function enforceEager(value: RuleValue): IRules;
-type EnforceEager = typeof enforceEager;
+type EnforceEager = (value: RuleValue) => IRules;
 type LazyRules = n4s.IRules<LazyRuleMethods>;
 type Lazy = LazyRules & LazyRuleMethods & 
 // This is a "catch all" hack to make TS happy while not
@@ -157,3 +146,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/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/eachEnforceRule.ts","../src/runtime/enforceContext.ts","../src/lib/isProxySupported.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"}

package/types/schema.d.ts

@@ -1,9 +1,5 @@
-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;
     message?: Stringable;
@@ -41,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;
@@ -70,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;
@@ -92,7 +88,7 @@ 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;
@@ -133,11 +129,12 @@ declare function partial<T extends Record<any, any>>(shapeObject: T): T;
 declare global {
     namespace n4s {
         interface EnforceCustomMatchers<R> {
-            isArrayOf: (...args: DropFirst<Parameters<typeof isArrayOf>>) => R;
-            loose: (...args: DropFirst<Parameters<typeof loose>>) => R;
-            shape: (...args: DropFirst<Parameters<typeof shape>>) => R;
-            optional: (...args: DropFirst<Parameters<typeof optional>>) => R;
+            isArrayOf: EnforceCustomMatcher<typeof isArrayOf, R>;
+            loose: EnforceCustomMatcher<typeof loose, R>;
+            shape: EnforceCustomMatcher<typeof shape, R>;
+            optional: EnforceCustomMatcher<typeof optional, R>;
         }
     }
 }
 export { partial };
+//# sourceMappingURL=schema.d.ts.map

package/types/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/exports/schema.ts","../src/lib/enforceUtilityTypes.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/eachEnforceRule.ts","../src/runtime/enforceContext.ts","../src/lib/isProxySupported.ts","../src/lib/transformResult.ts","../src/runtime/genEnforceLazy.ts","../src/lib/runLazyRule.ts","../src/plugins/schema/isArrayOf.ts","../src/plugins/schema/schemaTypes.ts","../src/plugins/schema/loose.ts","../src/plugins/schema/optional.ts","../src/plugins/schema/shape.ts","../src/plugins/schema/partial.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;YAC/B,SAAS,EAAE,oBAAoB,CAAC,OAAO,SAAS,EAAE,CAAC,CAAC,CAAC;YACrD,KAAK,EAAE,oBAAoB,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC;YAC7C,KAAK,EAAE,oBAAoB,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC;YAC7C,QAAQ,EAAE,oBAAoB,CAAC,OAAO,QAAQ,EAAE,CAAC,CAAC,CAAC;SACpD;KACF;CACF;AAdD,OAAO,WAAW,CAAgB"}