is-what 3.8.0 → 3.11.0

package/build/rollup.js

@@ -23,7 +23,7 @@ const name = pkg.name
 const className = name.replace(/(^\w|-\w)/g, c => c.replace('-', '').toUpperCase())
 const external = Object.keys(pkg.dependencies || [])
 const plugins = [
-  typescript({useTsconfigDeclarationDir: true}),
+  typescript({ useTsconfigDeclarationDir: true, tsconfigOverride: { exclude: ['test/**/*'] } }),
 ]
 
 // ------------------------------------------------------------------------------------------
@@ -33,15 +33,18 @@ function defaults (config) {
   // defaults
   const defaults = {
     plugins,
-    external
+    external,
   }
   // defaults.output
   config.output = config.output.map(output => {
-    return Object.assign({
-      sourcemap: false,
-      name: className,
-      exports: 'named',
-    }, output)
+    return Object.assign(
+      {
+        sourcemap: false,
+        name: className,
+        exports: 'named',
+      },
+      output
+    )
   })
   return Object.assign(defaults, config)
 }
@@ -50,8 +53,8 @@ export default [
   defaults({
     input: 'src/index.ts',
     output: [
-      {file: 'dist/index.cjs.js', format: 'cjs'},
-      {file: 'dist/index.esm.js', format: 'esm'},
+      { file: 'dist/index.cjs.js', format: 'cjs' },
+      { file: 'dist/index.esm.js', format: 'esm' },
     ],
   }),
 ]

package/dist/index.cjs.js

@@ -49,6 +49,15 @@ function isPlainObject(payload) {
 function isObject(payload) {
     return isPlainObject(payload);
 }
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is {}}
+ */
+function isEmptyObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length === 0;
+}
 /**
  * Returns whether the payload is an any kind of object (including special classes or objects with different prototypes)
  *
@@ -88,6 +97,15 @@ function isFunction(payload) {
 function isArray(payload) {
     return getType(payload) === 'Array';
 }
+/**
+ * Returns whether the payload is a an empty array
+ *
+ * @param {*} payload
+ * @returns {payload is []}
+ */
+function isEmptyArray(payload) {
+    return isArray(payload) && payload.length === 0;
+}
 /**
  * Returns whether the payload is a string
  *
@@ -234,6 +252,15 @@ function isPromise(payload) {
 function isError(payload) {
     return getType(payload) === 'Error';
 }
+/**
+ * Returns whether the payload is `NaN` but also a `number`
+ *
+ * @param {*} payload
+ * @returns {payload is typeof NaN}
+ */
+function isNaNValue(payload) {
+    return getType(payload) === 'Number' && isNaN(payload);
+}
 /**
  * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
  *
@@ -286,12 +313,15 @@ exports.isArray = isArray;
 exports.isBlob = isBlob;
 exports.isBoolean = isBoolean;
 exports.isDate = isDate;
+exports.isEmptyArray = isEmptyArray;
+exports.isEmptyObject = isEmptyObject;
 exports.isEmptyString = isEmptyString;
 exports.isError = isError;
 exports.isFile = isFile;
 exports.isFullString = isFullString;
 exports.isFunction = isFunction;
 exports.isMap = isMap;
+exports.isNaNValue = isNaNValue;
 exports.isNull = isNull;
 exports.isNullOrUndefined = isNullOrUndefined;
 exports.isNumber = isNumber;

package/dist/index.esm.js

@@ -45,6 +45,15 @@ function isPlainObject(payload) {
 function isObject(payload) {
     return isPlainObject(payload);
 }
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is {}}
+ */
+function isEmptyObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length === 0;
+}
 /**
  * Returns whether the payload is an any kind of object (including special classes or objects with different prototypes)
  *
@@ -84,6 +93,15 @@ function isFunction(payload) {
 function isArray(payload) {
     return getType(payload) === 'Array';
 }
+/**
+ * Returns whether the payload is a an empty array
+ *
+ * @param {*} payload
+ * @returns {payload is []}
+ */
+function isEmptyArray(payload) {
+    return isArray(payload) && payload.length === 0;
+}
 /**
  * Returns whether the payload is a string
  *
@@ -230,6 +248,15 @@ function isPromise(payload) {
 function isError(payload) {
     return getType(payload) === 'Error';
 }
+/**
+ * Returns whether the payload is `NaN` but also a `number`
+ *
+ * @param {*} payload
+ * @returns {payload is typeof NaN}
+ */
+function isNaNValue(payload) {
+    return getType(payload) === 'Number' && isNaN(payload);
+}
 /**
  * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
  *
@@ -276,4 +303,4 @@ function isType(payload, type) {
     return getType(payload) === name || Boolean(payload && payload.constructor === type);
 }
 
-export { getType, isAnyObject, isArray, isBlob, isBoolean, isDate, isEmptyString, isError, isFile, isFullString, isFunction, isMap, isNull, isNullOrUndefined, isNumber, isObject, isObjectLike, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isType, isUndefined, isWeakMap, isWeakSet };
+export { getType, isAnyObject, isArray, isBlob, isBoolean, isDate, isEmptyArray, isEmptyObject, isEmptyString, isError, isFile, isFullString, isFunction, isMap, isNaNValue, isNull, isNullOrUndefined, isNumber, isObject, isObjectLike, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isType, isUndefined, isWeakMap, isWeakSet };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "is-what",
   "sideEffects": false,
-  "version": "3.8.0",
+  "version": "3.11.0",
   "description": "JS type check (TypeScript supported) functions like `isPlainObject() isArray()` etc. A simple & small integration.",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
@@ -47,30 +47,32 @@
   "homepage": "https://github.com/mesqueeb/is-what#readme",
   "dependencies": {},
   "devDependencies": {
-    "@babel/core": "^7.9.0",
+    "@babel/core": "^7.11.0",
     "@types/babel-core": "^6.25.6",
-    "@types/jest": "^25.2.1",
-    "@typescript-eslint/eslint-plugin": "^2.27.0",
-    "@typescript-eslint/parser": "^2.27.0",
-    "ava": "^3.6.0",
+    "@types/jest": "^25.2.3",
+    "@typescript-eslint/eslint-plugin": "^2.34.0",
+    "@typescript-eslint/parser": "^2.34.0",
+    "ava": "^3.11.0",
     "babel-core": "^7.0.0-bridge.0",
-    "babel-jest": "^25.3.0",
+    "babel-jest": "^25.5.1",
     "babel-preset-env": "^1.7.0",
     "eslint": "^6.8.0",
-    "eslint-config-prettier": "^6.10.1",
+    "eslint-config-prettier": "^6.11.0",
     "eslint-plugin-tree-shaking": "^1.8.0",
-    "jest": "^25.3.0",
-    "regenerator-runtime": "^0.13.5",
+    "jest": "^25.5.4",
+    "regenerator-runtime": "^0.13.7",
     "rollup": "^1.32.1",
-    "rollup-plugin-typescript2": "^0.26.0",
-    "ts-node": "^8.8.2",
-    "typescript": "^3.8.3"
+    "rollup-plugin-typescript2": "^0.27.1",
+    "tsconfig-paths": "^3.9.0",
+    "ts-node": "^8.10.2",
+    "typescript": "^3.9.7"
   },
   "ava": {
     "extensions": [
       "ts"
     ],
     "require": [
+      "tsconfig-paths/register",
       "ts-node/register"
     ]
   }

package/src/index.ts

@@ -49,6 +49,16 @@ export function isObject (payload: any): payload is { [key: string]: any } {
   return isPlainObject(payload)
 }
 
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is {}}
+ */
+export function isEmptyObject (payload: any): payload is {} {
+  return isPlainObject(payload) && Object.keys(payload).length === 0
+}
+
 /**
  * Returns whether the payload is an any kind of object (including special classes or objects with different prototypes)
  *
@@ -92,6 +102,16 @@ export function isArray (payload: any): payload is any[] {
   return getType(payload) === 'Array'
 }
 
+/**
+ * Returns whether the payload is a an empty array
+ *
+ * @param {*} payload
+ * @returns {payload is []}
+ */
+export function isEmptyArray (payload: any): payload is [] {
+  return isArray(payload) && payload.length === 0
+}
+
 /**
  * Returns whether the payload is a string
  *
@@ -254,6 +274,16 @@ export function isError (payload: any): payload is Error {
   return getType(payload) === 'Error'
 }
 
+/**
+ * Returns whether the payload is `NaN` but also a `number`
+ *
+ * @param {*} payload
+ * @returns {payload is typeof NaN}
+ */
+export function isNaNValue (payload: any): payload is typeof NaN {
+  return getType(payload) === 'Number' && isNaN(payload)
+}
+
 /**
  * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
  *

package/test/ava.ts

@@ -1,6 +1,7 @@
 import test from 'ava'
 import {
   isError,
+  isEmptyArray,
   isObject,
   isPlainObject,
   isAnyObject,
@@ -26,6 +27,8 @@ import {
   // isBlob,
   // isFile,
   isPromise,
+  isNaNValue,
+  isEmptyObject,
 } from '../src/index'
 
 // const blob = Buffer.from([])
@@ -88,6 +91,74 @@ test('Basic false tests', t => {
   t.is(isNullOrUndefined(NaN), false)
 })
 
+test('isEmptyObject', t => {
+  t.is(isEmptyObject({}), true)
+  t.is(isEmptyObject(new Object()), true)
+
+  t.is(isEmptyObject('{}'), false)
+  t.is(isEmptyObject('{}'), false)
+  t.is(isEmptyObject(null), false)
+  t.is(isEmptyObject(new Date()), false)
+  t.is(isEmptyObject(new Error('')), false)
+  t.is(isEmptyObject(new Date()), false)
+  t.is(isEmptyObject(Symbol()), false)
+  t.is(isEmptyObject(new Map()), false)
+  t.is(isEmptyObject(new WeakMap()), false)
+  t.is(isEmptyObject(new Set()), false)
+  t.is(isEmptyObject(new WeakSet()), false)
+})
+
+test('isEmptyArray', t => {
+  t.is(isEmptyArray([]), true)
+  t.is(isEmptyArray(new Array()), true)
+  t.is(isEmptyArray(new Array(0)), true)
+  
+  t.is(isEmptyArray(new Array(1)), false)
+  t.is(isEmptyArray([undefined]), false)
+  t.is(isEmptyArray(null), false)
+  t.is(isEmptyArray(new Date()), false)
+  t.is(isEmptyArray(new Error('')), false)
+  t.is(isEmptyArray(new Date()), false)
+  t.is(isEmptyArray(Symbol()), false)
+  t.is(isEmptyArray(new Map()), false)
+  t.is(isEmptyArray(new WeakMap()), false)
+  t.is(isEmptyArray(new Set()), false)
+  t.is(isEmptyArray(new WeakSet()), false)
+})
+
+test('NaN tests', t => {
+  t.is(isNaNValue(NaN), true)
+  t.is(isNaNValue(new Error('')), false)
+  t.is(isNaNValue(undefined), false)
+  t.is(isNaNValue(null), false)
+  t.is(isNaNValue(undefined), false)
+  t.is(isNaNValue({}), false)
+  t.is(isNaNValue(new Object()), false)
+  t.is(
+    isNaNValue(_ => {}),
+    false
+  )
+  t.is(isNaNValue([]), false)
+  t.is(isNaNValue(new Array()), false)
+  t.is(isNaNValue(''), false)
+  t.is(isNaNValue('_'), false)
+  t.is(isNaNValue(''), false)
+  t.is(isNaNValue(' '), false)
+  t.is(isNaNValue(true), false)
+  t.is(isNaNValue(false), false)
+  t.is(isNaNValue(/./), false)
+  t.is(isNaNValue(/./gi), false)
+  t.is(isNaNValue(0), false)
+  t.is(isNaNValue(1), false)
+  t.is(isNaNValue(new Date()), false)
+  t.is(isNaNValue(Symbol()), false)
+  t.is(isNaNValue(new Map()), false)
+  t.is(isNaNValue(new WeakMap()), false)
+  t.is(isNaNValue(new Set()), false)
+  t.is(isNaNValue(new WeakSet()), false)
+  t.is(isNaNValue(new Promise((resolve, reject) => {})), false)
+})
+
 test('Primitive tests', t => {
   // true
   t.is(isPrimitive(0), true)

package/tsconfig.json

@@ -1,9 +1,11 @@
 {
   "compilerOptions": {
+    "baseUrl": ".",
     "declaration": true,
     "declarationDir": "./types/"
   },
   "include": [
-    "src/**/*"
+    "src/**/*",
+    "test/**/*"
   ]
 }

package/types/index.d.ts

@@ -37,6 +37,13 @@ export declare function isPlainObject(payload: any): payload is {
 export declare function isObject(payload: any): payload is {
     [key: string]: any;
 };
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is {}}
+ */
+export declare function isEmptyObject(payload: any): payload is {};
 /**
  * Returns whether the payload is an any kind of object (including special classes or objects with different prototypes)
  *
@@ -70,6 +77,13 @@ export declare function isFunction(payload: any): payload is Function;
  * @returns {payload is undefined}
  */
 export declare function isArray(payload: any): payload is any[];
+/**
+ * Returns whether the payload is a an empty array
+ *
+ * @param {*} payload
+ * @returns {payload is []}
+ */
+export declare function isEmptyArray(payload: any): payload is [];
 /**
  * Returns whether the payload is a string
  *
@@ -184,6 +198,13 @@ export declare function isPromise(payload: any): payload is Promise<any>;
  * @returns {payload is Error}
  */
 export declare function isError(payload: any): payload is Error;
+/**
+ * Returns whether the payload is `NaN` but also a `number`
+ *
+ * @param {*} payload
+ * @returns {payload is typeof NaN}
+ */
+export declare function isNaNValue(payload: any): payload is typeof NaN;
 /**
  * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
  *