n4s 3.0.0 → 4.0.0-dev-1aae50

package/dist/umd/schema.development.js

@@ -0,0 +1,148 @@
+(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 mapFirst(array, callback) {
+      var broke = false;
+      var breakoutValue = null;
+      for (var i = 0; i < array.length; i++) {
+          callback(array[i], breakout, i);
+          if (broke) {
+              return breakoutValue;
+          }
+      }
+      function breakout(value) {
+          broke = true;
+          breakoutValue = value;
+      }
+  }
+
+  function isFunction(value) {
+      return typeof value === 'function';
+  }
+
+  function optionalFunctionValue(value) {
+      var args = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+          args[_i - 1] = arguments[_i];
+      }
+      return isFunction(value) ? value.apply(void 0, args) : value;
+  }
+
+  function defaultTo(callback, defaultValue) {
+      var _a;
+      return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
+  }
+
+  function ruleReturn(pass, message) {
+      var output = { pass: pass };
+      if (message) {
+          output.message = message;
+      }
+      return output;
+  }
+  function failing() {
+      return ruleReturn(false);
+  }
+  function passing() {
+      return ruleReturn(true);
+  }
+  function defaultToPassing(callback) {
+      return defaultTo(callback, passing());
+  }
+
+  function runLazyRule(lazyRule, currentValue) {
+      try {
+          return lazyRule.run(currentValue);
+      }
+      catch (_a) {
+          return failing();
+      }
+  }
+
+  function isArrayOf(inputArray, currentRule) {
+      return defaultToPassing(mapFirst(inputArray, function (currentValue, breakout, index) {
+          var res = n4s.ctx.run({ value: currentValue, set: true, meta: { index: index } }, function () { return runLazyRule(currentRule, currentValue); });
+          if (!res.pass) {
+              breakout(res);
+          }
+      }));
+  }
+
+  function loose(inputObject, shapeObject) {
+      var _loop_1 = function (key) {
+          var currentValue = inputObject[key];
+          var currentRule = shapeObject[key];
+          var res = n4s.ctx.run({ value: currentValue, set: true, meta: { key: key } }, function () {
+              return runLazyRule(currentRule, currentValue);
+          });
+          if (!res.pass) {
+              return { value: res };
+          }
+      };
+      for (var key in shapeObject) {
+          var state_1 = _loop_1(key);
+          if (typeof state_1 === "object")
+              return state_1.value;
+      }
+      return passing();
+  }
+
+  function isNull(value) {
+      return value === null;
+  }
+
+  function isUndefined(value) {
+      return value === undefined;
+  }
+
+  function isNullish(value) {
+      return isNull(value) || isUndefined(value);
+  }
+
+  function optional(value, ruleChain) {
+      if (isNullish(value)) {
+          return passing();
+      }
+      return runLazyRule(ruleChain, value);
+  }
+
+  /**
+   * A safe hasOwnProperty access
+   */
+  function hasOwnProperty(obj, key) {
+      return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+
+  function shape(inputObject, shapeObject) {
+      var baseRes = loose(inputObject, shapeObject);
+      if (!baseRes.pass) {
+          return baseRes;
+      }
+      for (var key in inputObject) {
+          if (!hasOwnProperty(shapeObject, key)) {
+              return failing();
+          }
+      }
+      return passing();
+  }
+
+  // Help needed improving the typings of this file.
+  // Ideally, we'd be able to extend IShapeObject, but that's not possible.
+  function partial(shapeObject) {
+      var output = {};
+      for (var key in shapeObject) {
+          output[key] = n4s.enforce.optional(shapeObject[key]);
+      }
+      return output;
+  }
+
+  n4s.enforce.extend({ isArrayOf: isArrayOf, loose: loose, optional: optional, shape: shape });
+
+  exports.partial = partial;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

package/dist/umd/schema.production.js

@@ -0,0 +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,e){return n={pass:n},e&&(n.message=e),n}function r(n,e){try{return n.run(e)}catch(n){return t(!1)}}function o(n,o){var u,f=function(t){var u=n[t],f=o[t];if(!(t=e.ctx.run({value:u,set:!0,meta:{key:t}},(function(){return r(f,u)}))).pass)return{value:t}};for(u in o){var i=f(u);if("object"==typeof i)return i.value}return t(!0)}e.enforce.extend({isArrayOf:function(n,o){return function(n,e){var t;return null!==(t=function(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}(n))&&void 0!==t?t:e}(function(n,e){function t(n){r=!0,o=n}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,u){(u=e.ctx.run({value:n,set:!0,meta:{index:u}},(function(){return r(o,n)}))).pass||t(u)})),t(!0))},loose:o,optional:function(n,e){return null==n?t(!0):r(e,n)},shape:function(n,e){var r=o(n,e);if(!r.pass)return r;for(var u in n)if(!Object.prototype.hasOwnProperty.call(e,u))return t(!1);return t(!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})}));

package/docs/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 instead, you can use its lazy validation interface:
 
 ```js
-enforce
-  .isArray()
-  .longerThan(3)
-  .test([1,2,3])
+enforce.isArray().longerThan(3).test([1, 2, 3]);
 ```
 
 ## Content

package/docs/_sidebar.md

@@ -1,6 +1,5 @@
 - [Main](./)
 - [List of Enforce Rules](./rules)
-- [Schema validations](./coumpound)
-- [Templates and Composites](./template)
+- [Schema validations](./compound)
 - [Custom Enforce Rules](./custom)
 - [Consuming external rules](./external)

package/docs/external.md

@@ -24,31 +24,4 @@ enforce('example@example.com').isEmail(); // ✅
 enforce('example[at]example[dot]com').isEmail(); // 🚨
 ```
 
-A full list of the supported validator.js rules can be found on [npmjs.com/package/validator](https://www.npmjs.com/package/validator). Some common rules are:
-
-- isAfter
-- isBefore
-- isBtcAddress
-- isCreditCard
-- isCurrency
-- isDate
-- isEmail
-- isFQDN
-- isIBAN
-- isIdentityCard
-- isIP
-- isIPRange
-- isJSON
-- isJWT
-- isMACAddress
-- isMD5
-- isMimeType
-- isMobilePhone
-- isMongoId
-- isPassportNumber
-- isPort
-- isPostalCode
-- isSlug
-- isURL
-- isTaxID
-- isUUID
+A full list of the supported validator.js rules can be found on [npmjs.com/package/validator](https://www.npmjs.com/package/validator).

package/docs/rules.md

@@ -30,6 +30,8 @@ Enforce rules are functions that allow you to test your data against different c
 - [isNotArray](#isnotarray)
 - [isBoolean](#isboolean)
 - [isNotBoolean](#isnotboolean)
+- [isBlank](#isblank)
+- [isNotBlank](#isnotblank)
 - [isNumber](#isnumber)
 - [isNotNumber](#isnotnumber)
 - [isNaN](#isNaN)
@@ -856,6 +858,32 @@ enforce(false).isNotBoolean();
 // throws
 ```
 
+## isBlank
+
+### Description
+
+Determines wheter an enforced string contains only whitespaces
+
+### Usage examples:
+
+```js
+enforce('   ').isBlank(); // passes
+enforce('not blank').isBlank(); // throws
+```
+
+## isNotBlank
+
+### Description
+
+Determines wheter an enforced string contains at least a non-whitespace character
+
+### Usage examples:
+
+```js
+enforce('not blank').isNotBlank(); // passes
+enforce('   ').isNotBlank(); // throws
+```
+
 ## isNumber
 
 ### Description

package/package.json

@@ -1,51 +1,138 @@
 {
+  "version": "4.0.0-dev-1aae50",
+  "license": "MIT",
+  "main": "./dist/cjs/n4s.js",
+  "types": "./types/n4s.d.ts",
   "name": "n4s",
-  "version": "3.0.0",
-  "description": "Enforce - Validation assertions library",
-  "main": "./n4s.js",
-  "browser": "./n4s.js",
+  "author": "ealush",
+  "scripts": {
+    "test": "vx test",
+    "release": "vx release"
+  },
+  "dependencies": {
+    "context": "2.0.0-dev-1aae50"
+  },
+  "module": "./dist/es/n4s.production.js",
   "exports": {
-    "./n4s.js": "./n4s.js",
-    "./package.json": "./package.json",
-    "./esm/n4s.mjs.development.js": "./esm/n4s.mjs.development.js",
-    "./esm/n4s.mjs.production.js": "./esm/n4s.mjs.production.js",
-    "./esm/n4s.mjs.production.min.js": "./esm/n4s.mjs.production.min.js",
-    "./n4s.cjs.development.js": "./n4s.cjs.development.js",
-    "./n4s.cjs.production.js": "./n4s.cjs.production.js",
-    "./n4s.cjs.production.min.js": "./n4s.cjs.production.min.js",
-    "./n4s.umd.development.js": "./n4s.umd.development.js",
-    "./n4s.umd.production.js": "./n4s.umd.production.js",
-    "./n4s.umd.production.min.js": "./n4s.umd.production.min.js",
+    "./compose": {
+      "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"
+      },
+      "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/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"
+    },
+    "./compounds": {
+      "production": {
+        "types": "./types/compounds.d.ts",
+        "browser": "./dist/es/compounds.production.js",
+        "umd": "./dist/umd/compounds.production.js",
+        "import": "./dist/es/compounds.production.js",
+        "require": "./dist/cjs/compounds.production.js",
+        "node": "./dist/cjs/compounds.production.js",
+        "module": "./dist/es/compounds.production.js",
+        "default": "./dist/cjs/compounds.production.js"
+      },
+      "development": {
+        "types": "./types/compounds.d.ts",
+        "browser": "./dist/es/compounds.development.js",
+        "umd": "./dist/umd/compounds.development.js",
+        "import": "./dist/es/compounds.development.js",
+        "require": "./dist/cjs/compounds.development.js",
+        "node": "./dist/cjs/compounds.development.js",
+        "module": "./dist/es/compounds.development.js",
+        "default": "./dist/cjs/compounds.development.js"
+      },
+      "types": "./types/compounds.d.ts",
+      "browser": "./dist/es/compounds.production.js",
+      "umd": "./dist/umd/compounds.production.js",
+      "import": "./dist/es/compounds.production.js",
+      "require": "./dist/cjs/compounds.production.js",
+      "node": "./dist/cjs/compounds.production.js",
+      "module": "./dist/es/compounds.production.js",
+      "default": "./dist/cjs/compounds.production.js"
+    },
+    "./schema": {
+      "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"
+      },
+      "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/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"
+    },
     ".": {
-      "browser": "./n4s.js",
-      "import": "./esm/n4s.mjs.production.js",
-      "require": "./n4s.cjs.production.js",
-      "node": "./n4s.cjs.production.js",
-      "default": "./n4s.cjs.production.js"
-    }
+      "development": {
+        "types": "./types/n4s.d.ts",
+        "browser": "./dist/es/n4s.development.js",
+        "umd": "./dist/umd/n4s.development.js",
+        "import": "./dist/es/n4s.development.js",
+        "require": "./dist/cjs/n4s.development.js",
+        "node": "./dist/cjs/n4s.development.js",
+        "module": "./dist/es/n4s.development.js",
+        "default": "./dist/cjs/n4s.development.js"
+      },
+      "types": "./types/n4s.d.ts",
+      "browser": "./dist/es/n4s.production.js",
+      "umd": "./dist/umd/n4s.production.js",
+      "import": "./dist/es/n4s.production.js",
+      "require": "./dist/cjs/n4s.production.js",
+      "node": "./dist/cjs/n4s.production.js",
+      "module": "./dist/es/n4s.production.js",
+      "default": "./dist/cjs/n4s.production.js"
+    },
+    "./package.json": "./package.json",
+    "./": "./"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ealush/vest.git"
+    "url": "https://github.com/ealush/vest.git",
+    "directory": "packages/n4s"
   },
-  "keywords": [
-    "assertion",
-    "enforce",
-    "ensure",
-    "passable",
-    "vest",
-    "n4s",
-    "validations"
-  ],
-  "author": "ealush",
-  "license": "MIT",
   "bugs": {
-    "url": "https://github.com/ealush/vest/issues"
-  },
-  "homepage": "https://github.com/ealush/vest/tree/latest/packages/n4s",
-  "scripts": {
-    "build": "rollup -c ./config/rollup/rollup.config.js",
-    "test": "jest"
-  },
-  "module": "./esm/n4s.mjs.production.js"
-}
+    "url": "https://github.com/ealush/vest.git/issues"
+  }
+}

package/schema/package.json

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

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declarationMap": true,
+    "declarationDir": "./types",
+    "outDir": "./dist"
+  }
+}

package/types/compose.d.ts

@@ -0,0 +1,134 @@
+type DropFirst<T extends unknown[]> = T extends [
+    unknown,
+    ...infer U
+] ? U : never;
+type TStringable = string | ((...args: any[]) => string);
+type TRuleReturn = boolean | {
+    pass: boolean;
+    message?: TStringable;
+};
+type TRuleDetailedResult = {
+    pass: boolean;
+    message?: string;
+};
+type TArgs = any[];
+type TBaseRules = typeof baseRules;
+type KBaseRules = keyof TBaseRules;
+declare function condition(value: any, callback: (value: any) => TRuleReturn): TRuleReturn;
+declare function endsWith(value: string, arg1: string): boolean;
+declare function equals(value: unknown, arg1: unknown): boolean;
+declare function greaterThan(value: number | string, gt: number | string): boolean;
+declare function greaterThanOrEquals(value: string | number, gte: string | number): boolean;
+declare function inside(value: unknown, arg1: string | unknown[]): boolean;
+// The module is named "isArrayValue" since it
+// is conflicting with a nested npm dependency.
+// We may need to revisit this in the future.
+declare function isArray(value: unknown): value is Array<unknown>;
+declare function isBetween(value: number | string, min: number | string, max: number | string): boolean;
+declare function isBlank(value: unknown): boolean;
+declare function isBoolean(value: unknown): value is boolean;
+declare function isEmpty(value: unknown): boolean;
+declare function isNaN(value: unknown): boolean;
+declare function isNegative(value: number | string): boolean;
+declare function isNull(value: unknown): value is null;
+declare function isNullish(value: any): value is null | undefined;
+declare function isNumber(value: unknown): value is number;
+declare function isNumeric(value: string | number): boolean;
+declare function isStringValue(v: unknown): v is string;
+declare function isTruthy(value: unknown): boolean;
+declare function isUndefined(value?: unknown): boolean;
+declare function lengthEquals(value: string | unknown[], arg1: string | number): boolean;
+declare function lessThan(value: string | number, lt: string | number): boolean;
+declare function lessThanOrEquals(value: string | number, lte: string | number): boolean;
+declare function longerThan(value: string | unknown[], arg1: string | number): boolean;
+declare function longerThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
+declare function matches(value: string, regex: RegExp | string): boolean;
+declare function numberEquals(value: string | number, eq: string | number): boolean;
+declare function shorterThan(value: string | unknown[], arg1: string | number): boolean;
+declare function shorterThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
+declare function startsWith(value: string, arg1: string): boolean;
+declare const baseRules: {
+    condition: typeof condition;
+    doesNotEndWith: (value: string, arg1: string) => boolean;
+    doesNotStartWith: (value: string, arg1: string) => boolean;
+    endsWith: typeof endsWith;
+    equals: typeof equals;
+    greaterThan: typeof greaterThan;
+    greaterThanOrEquals: typeof greaterThanOrEquals;
+    gt: typeof greaterThan;
+    gte: typeof greaterThanOrEquals;
+    inside: typeof inside;
+    isArray: typeof isArray;
+    isBetween: typeof isBetween;
+    isBlank: typeof isBlank;
+    isBoolean: typeof isBoolean;
+    isEmpty: typeof isEmpty;
+    isEven: (value: any) => boolean;
+    isFalsy: (value: unknown) => boolean;
+    isNaN: typeof isNaN;
+    isNegative: typeof isNegative;
+    isNotArray: (value: unknown) => boolean;
+    isNotBetween: (value: string | number, min: string | number, max: string | number) => boolean;
+    isNotBlank: (value: unknown) => boolean;
+    isNotBoolean: (value: unknown) => boolean;
+    isNotEmpty: (value: unknown) => boolean;
+    isNotNaN: (value: unknown) => boolean;
+    isNotNull: (value: unknown) => boolean;
+    isNotNullish: (value: any) => boolean;
+    isNotNumber: (value: unknown) => boolean;
+    isNotNumeric: (value: string | number) => boolean;
+    isNotString: (v: unknown) => boolean;
+    isNotUndefined: (value?: unknown) => boolean;
+    isNull: typeof isNull;
+    isNullish: typeof isNullish;
+    isNumber: typeof isNumber;
+    isNumeric: typeof isNumeric;
+    isOdd: (value: any) => boolean;
+    isPositive: (value: string | number) => boolean;
+    isString: typeof isStringValue;
+    isTruthy: typeof isTruthy;
+    isUndefined: typeof isUndefined;
+    lengthEquals: typeof lengthEquals;
+    lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
+    lessThan: typeof lessThan;
+    lessThanOrEquals: typeof lessThanOrEquals;
+    longerThan: typeof longerThan;
+    longerThanOrEquals: typeof longerThanOrEquals;
+    lt: typeof lessThan;
+    lte: typeof lessThanOrEquals;
+    matches: typeof matches;
+    notEquals: (value: unknown, arg1: unknown) => boolean;
+    notInside: (value: unknown, arg1: string | unknown[]) => boolean;
+    notMatches: (value: string, regex: string | RegExp) => boolean;
+    numberEquals: typeof numberEquals;
+    numberNotEquals: (value: string | number, eq: string | number) => boolean;
+    shorterThan: typeof shorterThan;
+    shorterThanOrEquals: typeof shorterThanOrEquals;
+    startsWith: typeof startsWith;
+};
+type TRules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<TRules<E> & E> & Record<string, (...args: TArgs) => TRules<E> & E> & {
+    [P in KBaseRules]: (...args: DropFirst<Parameters<TBaseRules[P]>> | TArgs) => TRules<E> & E;
+};
+/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
+declare global {
+    namespace n4s {
+        interface IRules<E> extends TRules<E> {
+        }
+    }
+}
+type TLazyRules = n4s.IRules<TLazyRuleMethods>;
+type TLazy = TLazyRules & TLazyRuleMethods & 
+// This is a "catch all" hack to make TS happy while not
+// losing type hints
+Record<string, (...args: any[]) => any>;
+type TLazyRuleMethods = TLazyRuleRunners & {
+    message: (message: TLazyMessage) => TLazy;
+};
+type TLazyRuleRunners = {
+    test: (value: unknown) => boolean;
+    run: (value: unknown) => TRuleDetailedResult;
+};
+type TComposeResult = TLazyRuleRunners & ((value: any) => void);
+type TLazyMessage = string | ((value: unknown, originalMessage?: TStringable) => string);
+declare function compose(...composites: TLazyRuleRunners[]): TComposeResult;
+export { compose as default };