added: [n4s] add isNaN rule (#300)

.gitignore

@@ -1,22 +1,16 @@
 node_modules
 .vscode
-.sass-cache
-dev_docpress
-_docpress
-dev
-version.json
-version.txt
-.version
-documentation/MAIN.md
-documentation/assets/**/*.css
 .DS_Store
 *.log
+packages/vest/utilities/
+packages/n4s/extended/
+packages/n4s/dist
+
+# build artifacts
 packages/vest/dist
 packages/vest/esm
 packages/vest/*.js
+packages/vest/*.d.ts
 packages/vest/*.cjs
 packages/vest/*.mjs
-packages/vest/utilities/
-packages/n4s/dist
-packages/n4s/*.js
-packages/n4s/extended/
+packages/n4s/*.js

packages/n4s/docs/rules.md

@@ -30,6 +30,8 @@ Enforce rules are functions that allow you to test your data against different c
 - [isNotArray](#isnotarray)
 - [isNumber](#isnumber)
 - [isNotNumber](#isnotnumber)
+- [isNaN](#isNaN)
+- [isNotNaN](#isNotNaN)
 - [isString](#isstring)
 - [isNotString](#isnotstring)
 - [isOdd](#isodd)
@@ -802,6 +804,7 @@ enforce('hello').isNotArray();
 ### Description
 
 Checks if a value is of type `number`.
+Equals to `typeof value === 'number'`
 
 ### Usage examples:
 
@@ -824,6 +827,8 @@ enforce('143').isNumber();
 Checks if a value is of any type other than `number`.
 Reverse implementation of `isNumber`.
 
+**note** isNotNumber does not check for `NaN` value. For NaN values, use [isNaN](#isNaN).
+
 ### Usage examples:
 
 ```js
@@ -838,6 +843,48 @@ enforce(NaN).isNotNumber(); // throws (NaN is of type 'number!')
 // throws
 ```
 
+## isNaN
+
+### Description
+
+A wrapper around JavaScripts Number.isNaN() function. Checks if a value is NaN.
+
+### Usage examples:
+
+```js
+enforce(NaN).isNaN();
+enforce('A' / 'B').isNaN();
+// passes
+```
+
+```js
+enforce(null * null).isNaN(); // null*null = 0
+enforce(200).isNaN();
+enforce('1984').isNaN();
+// throws
+```
+
+## isNotNaN
+
+### Description
+
+Reverse implementation of `isNaN`. Checks that a value is not NaN.
+
+### Usage examples:
+
+```js
+enforce(null * null).isNaN(); // null*null = 0
+enforce(200).isNaN();
+enforce('1984').isNaN();
+// passes
+```
+
+```js
+enforce(NaN).isNaN();
+enforce('A' / 'B').isNaN();
+// throws
+```
+
 ## isString
 
 ### Description

packages/n4s/src/rules/index.js

@@ -6,6 +6,7 @@ import inside from './inside';
 import isArray from './isArray';
 import isEmpty from './isEmpty';
 import isEven from './isEven';
+import isNaN from './isNaN';
 import isNumber from './isNumber';
 import isNumeric from './isNumeric';
 import isOdd from './isOdd';
@@ -29,6 +30,7 @@ const rules = {
   isArray,
   isEmpty,
   isEven,
+  isNaN,
   isNumber,
   isNumeric,
   isOdd,

packages/n4s/src/rules/isNaN/index.js

@@ -0,0 +1,7 @@
+function isNaN(value) {
+  return Number.isNaN(value);
+}
+
+isNaN.negativeForm = 'isNotNaN';
+
+export default isNaN;

packages/n4s/src/rules/isNaN/spec.js

@@ -0,0 +1,28 @@
+import _isNaN from '.';
+
+describe('Tests isNaN rule', () => {
+  it('Should return true for `NaN` value', () => {
+    expect(_isNaN(NaN)).toBe(true);
+  });
+
+  it.each([
+    undefined,
+    null,
+    false,
+    true,
+    Object,
+    Array(0),
+    '',
+    ' ',
+    0,
+    1,
+    '0',
+    '1',
+  ])('Should return false for %s value', v => {
+    expect(_isNaN(v)).toBe(false);
+  });
+
+  it('Should expose negativeForm property', () => {
+    expect(_isNaN.negativeForm).toBe('isNotNaN');
+  });
+});

packages/n4s/src/rules/spec.js

@@ -15,6 +15,7 @@ describe('Tests enforce rules API', () => {
 const negativeRules = [
   'isNotArray',
   'isNotEmpty',
+  'isNotNaN',
   'isNotNumber',
   'isNotNumeric',
   'isNotString',
@@ -35,6 +36,7 @@ const positiveRules = [
   'isArray',
   'isEmpty',
   'isEven',
+  'isNaN',
   'isNumber',
   'isNumeric',
   'isOdd',

packages/vest/src/vest.d.ts

@@ -148,6 +148,8 @@ interface IEnforceRules<T = {}> {
   isEmpty: () => IEnforceRules<T> & EnforceExtendMap<T>;
   isEven: () => IEnforceRules<T> & EnforceExtendMap<T>;
   isNumber: () => IEnforceRules<T> & EnforceExtendMap<T>;
+  isNaN: () => IEnforceRules<T> & EnforceExtendMap<T>;
+  isNotNaN: () => IEnforceRules<T> & EnforceExtendMap<T>;
   isNumeric: () => IEnforceRules<T> & EnforceExtendMap<T>;
   isOdd: () => IEnforceRules<T> & EnforceExtendMap<T>;
   isTruthy: () => IEnforceRules<T> & EnforceExtendMap<T>;