is-what 3.14.0 → 4.1.1

package/README.md

@@ -1,6 +1,9 @@
 # is What? 🙉
 
-Very simple & small JS type check functions. It's fully TypeScript supported!
+<a href="https://www.npmjs.com/package/is-what"><img src="https://img.shields.io/npm/v/is-what.svg" alt="Total Downloads"></a>
+<a href="https://www.npmjs.com/package/is-what"><img src="https://img.shields.io/npm/dw/is-what.svg" alt="Latest Stable Version"></a>
+
+Very simple & small JS type check functions. It's fully TypeScript supported!
 
 ```
 npm i is-what
@@ -13,6 +16,7 @@ Or for deno available at: `"deno.land/x/is_what"`
 I built is-what because the existing solutions were all too complex or too poorly built.
 
 I was looking for:
+
 - A simple way to check any kind of type (including non-primitives)
 - Be able to check if an object is a plain object `{}` or a special object (like a class instance) ‼️
 - Let TypeScript automatically know what type a value is when checking
@@ -35,6 +39,12 @@ import { isString, isDate, isPlainObject } from 'is-what'
 ### Simple type check functions
 
 ```js
+// basics
+isBoolean(true) // true
+isBoolean(false) // true
+isUndefined(undefined) // true
+isNull(null) // true
+
 // strings
 isString('') // true
 isEmptyString('') // true
@@ -42,38 +52,86 @@ isFullString('') // false
 
 // numbers
 isNumber(0) // true
-isNumber(NaN) // false
+isNumber('0') // false
+isNumber(NaN) // false *
+isPositiveNumber(1) // true
+isNegativeNumber(-1) // true
+// * see below for special NaN use cases!
+
+// arrays
+isArray([]) // true
+isEmptyArray([]) // true
+isFullArray([1]) // true
+
+// objects
+isPlainObject({}) // true *
+isEmptyObject({}) // true
+isFullObject({ a: 1 }) // true
+// * see below for special object (& class instance) use cases!
+
+// functions
+isFunction(function () {}) // true
+isFunction(() => {}) // true
 
 // dates
 isDate(new Date()) // true
 isDate(new Date('invalid date')) // false
 
+// maps & sets
+isMap(new Map()) // true
+isSet(new Set()) // true
+isWeakMap(new WeakMap()) // true
+isWeakSet(new WeakSet()) // true
+
 // others
-isBoolean(false) // true
-isFunction(function () {}) // true
-isArray([]) // true
-isUndefined(undefined) // true
-isNull(null) // true
 isRegExp(/\s/gi) // true
 isSymbol(Symbol()) // true
 isBlob(new Blob()) // true
 isFile(new File([''], '', { type: 'text/html' })) // true
+isError(new Error('')) // true
+isPromise(new Promise((resolve) => {})) // true
 
 // primitives
 isPrimitive('') // true
 // true for any of: boolean, null, undefined, number, string, symbol
 ```
 
-### Getting and checking for specific types
+### Let's talk about NaN
 
-You can check for specific types with `getType` and `isType`:
+`isNaN` is a built-in JS Function but it really makes no sense:
 
 ```js
-import { getType, isType } from 'is-what'
+// 1)
+typeof NaN === 'number' // true
+// 🤔 ("not a number" is a "number"...)
 
-getType('') // returns 'String'
-// pass a Type as second param:
-isType('', String) // returns true
+// 2)
+isNaN('1') // false
+// 🤔 the string '1' is not-"not a number"... so it's a number??
+
+// 3)
+isNaN('one') // true
+// 🤔 'one' is NaN but `NaN === 'one'` is false...
+```
+
+With is-what the way we treat NaN makes a little bit more sense:
+
+```js
+import { isNumber, isNaNValue } from 'is-what'
+
+// 1)
+isNumber(NaN) // false!
+// let's not treat NaN as a number
+
+// 2)
+isNaNValue('1') // false
+// if it's not NaN, it's not NaN!!
+
+// 3)
+isNaNValue('one') // false
+// if it's not NaN, it's not NaN!!
+
+isNaNValue(NaN) // true
 ```
 
 ### isPlainObject vs isAnyObject
@@ -85,11 +143,11 @@ Checking for a JavaScript object can be really difficult. In JavaScript you can
 
 ```js
 // define a plain object
-const plainObject = {hello: 'I am a good old object.'}
+const plainObject = { hello: 'I am a good old object.' }
 
 // define a special object
 class SpecialObject {
-  constructor (somethingSpecial) {
+  constructor(somethingSpecial) {
     this.speciality = somethingSpecial
   }
 }
@@ -108,18 +166,30 @@ getType(specialObject) // returns 'Object'
 
 > Please note that `isPlainObject` will only return `true` for normal plain JavaScript objects.
 
+### Getting and checking for specific types
+
+You can check for specific types with `getType` and `isType`:
+
+```js
+import { getType, isType } from 'is-what'
+
+getType('') // returns 'String'
+// pass a Type as second param:
+isType('', String) // returns true
+```
+
 ## TypeScript
 
 is-what makes TypeScript know the type during if statements. This means that a check returns the type of the payload for TypeScript users.
 
 ```ts
-function isNumber (payload: any): payload is number {
+function isNumber(payload: any): payload is number {
   // return boolean
 }
 // As you can see above, all functions return a boolean for JavaScript, but pass the payload type to TypeScript.
 
 // usage example:
-function fn (payload: string | number): number {
+function fn(payload: string | number): number {
   if (isNumber(payload)) {
     // ↑ TypeScript already knows payload is a number here!
     return payload
@@ -131,8 +201,8 @@ function fn (payload: string | number): number {
 `isPlainObject` and `isAnyObject` with TypeScript will declare the payload to be an object type with any props:
 
 ```ts
-function isPlainObject (payload: any): payload is {[key: string]: any}
-function isAnyObject (payload: any): payload is {[key: string]: any}
+function isPlainObject(payload: any): payload is { [key: string]: any }
+function isAnyObject(payload: any): payload is { [key: string]: any }
 // The reason to return `{[key: string]: any}` is to be able to do
 if (isPlainObject(payload) && payload.id) return payload.id
 // if isPlainObject() would return `payload is object` then it would give an error at `payload.id`
@@ -140,20 +210,34 @@ if (isPlainObject(payload) && payload.id) return payload.id
 
 ### isObjectLike
 
-If you want more control over which kind of objects are allowed you can use `isObjectLike<T>`:
+If you want more control over what kind of interface/type is casted when checking for objects.
+
+To cast to a specific type while checking for `isAnyObject`, can use `isObjectLike<T>`:
 
 ```ts
 import { isObjectLike } from 'is-what'
-// usage examples:
-isObjectLike<{specificKey: string}>(payload)
-isObjectLike<object>(payload)
-// you can pass a specific type for TS to check on.
+
+const payload = { name: 'Mesqueeb' } // current type: `{ name: string }`
+
+// Without casting:
+if (isAnyObject(payload)) {
+  // in here `payload` is casted to: `Record<string | number | symbol, any>`
+  // WE LOOSE THE TYPE!
+}
+
+// With casting:
+// you can pass a specific type for TS that will be casted when the function returns
+if (isObjectLike<{ name: string }>(payload)) {
+  // in here `payload` is casted to: `{ name: string }`
+}
 ```
 
+Please note: this library will not actually check the shape of the object, you need to do that yourself.
+
 `isObjectLike<T>` works like this under the hood:
 
 ```ts
-function isObjectLike<T extends object> (payload: any): payload is T {
+function isObjectLike<T extends object>(payload: any): payload is T {
   return isAnyObject(payload)
 }
 ```
@@ -173,16 +257,16 @@ function isObjectLike<T extends object> (payload: any): payload is T {
 It's litterally just these functions:
 
 ```js
-function getType (payload) {
+function getType(payload) {
   return Object.prototype.toString.call(payload).slice(8, -1)
 }
-function isUndefined (payload) {
+function isUndefined(payload) {
   return getType(payload) === 'Undefined'
 }
-function isString (payload) {
+function isString(payload) {
   return getType(payload) === 'String'
 }
-function isAnyObject (payload) {
+function isAnyObject(payload) {
   return getType(payload) === 'Object'
 }
 // etc...

package/dist/{index.cjs.js → index.cjs}

@@ -33,7 +33,7 @@ function isNull(payload) {
  * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
  *
  * @param {*} payload
- * @returns {payload is Record<string, any>}
+ * @returns {payload is PlainObject}
  */
 function isPlainObject(payload) {
     if (getType(payload) !== 'Object')
@@ -44,7 +44,7 @@ function isPlainObject(payload) {
  * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
  *
  * @param {*} payload
- * @returns {payload is Record<string, any>}
+ * @returns {payload is PlainObject}
  */
 function isObject(payload) {
     return isPlainObject(payload);
@@ -58,11 +58,20 @@ function isObject(payload) {
 function isEmptyObject(payload) {
     return isPlainObject(payload) && Object.keys(payload).length === 0;
 }
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+function isFullObject(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)
  *
  * @param {*} payload
- * @returns {payload is Record<string, any>}
+ * @returns {payload is PlainObject}
  */
 function isAnyObject(payload) {
     return getType(payload) === 'Object';
@@ -153,6 +162,24 @@ function isEmptyString(payload) {
 function isNumber(payload) {
     return getType(payload) === 'Number' && !isNaN(payload);
 }
+/**
+ * Returns whether the payload is a positive number (but not 0)
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+function isPositiveNumber(payload) {
+    return isNumber(payload) && payload > 0;
+}
+/**
+ * Returns whether the payload is a negative number (but not 0)
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+function isNegativeNumber(payload) {
+    return isNumber(payload) && payload < 0;
+}
 /**
  * Returns whether the payload is a boolean
  *
@@ -290,11 +317,9 @@ function isPrimitive(payload) {
  * @param {*} payload
  * @returns {(payload is null | undefined)}
  */
-var isNullOrUndefined = isOneOf(isNull, isUndefined);
+const isNullOrUndefined = isOneOf(isNull, isUndefined);
 function isOneOf(a, b, c, d, e) {
-    return function (value) {
-        return a(value) || b(value) || (!!c && c(value)) || (!!d && d(value)) || (!!e && e(value));
-    };
+    return (value) => a(value) || b(value) || (!!c && c(value)) || (!!d && d(value)) || (!!e && e(value));
 }
 /**
  * Does a generic check to check that the given payload is of a given type.
@@ -315,7 +340,7 @@ function isType(payload, type) {
         throw new TypeError('Type is not a class');
     }
     // Classes usually have names (as functions usually have names)
-    var name = type.name;
+    const name = type.name;
     return getType(payload) === name || Boolean(payload && payload.constructor === type);
 }
 
@@ -331,10 +356,12 @@ exports.isEmptyString = isEmptyString;
 exports.isError = isError;
 exports.isFile = isFile;
 exports.isFullArray = isFullArray;
+exports.isFullObject = isFullObject;
 exports.isFullString = isFullString;
 exports.isFunction = isFunction;
 exports.isMap = isMap;
 exports.isNaNValue = isNaNValue;
+exports.isNegativeNumber = isNegativeNumber;
 exports.isNull = isNull;
 exports.isNullOrUndefined = isNullOrUndefined;
 exports.isNumber = isNumber;
@@ -342,6 +369,7 @@ exports.isObject = isObject;
 exports.isObjectLike = isObjectLike;
 exports.isOneOf = isOneOf;
 exports.isPlainObject = isPlainObject;
+exports.isPositiveNumber = isPositiveNumber;
 exports.isPrimitive = isPrimitive;
 exports.isPromise = isPromise;
 exports.isRegExp = isRegExp;

package/dist/{index.esm.js → index.es.js}

@@ -29,7 +29,7 @@ function isNull(payload) {
  * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
  *
  * @param {*} payload
- * @returns {payload is Record<string, any>}
+ * @returns {payload is PlainObject}
  */
 function isPlainObject(payload) {
     if (getType(payload) !== 'Object')
@@ -40,7 +40,7 @@ function isPlainObject(payload) {
  * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
  *
  * @param {*} payload
- * @returns {payload is Record<string, any>}
+ * @returns {payload is PlainObject}
  */
 function isObject(payload) {
     return isPlainObject(payload);
@@ -54,11 +54,20 @@ function isObject(payload) {
 function isEmptyObject(payload) {
     return isPlainObject(payload) && Object.keys(payload).length === 0;
 }
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+function isFullObject(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)
  *
  * @param {*} payload
- * @returns {payload is Record<string, any>}
+ * @returns {payload is PlainObject}
  */
 function isAnyObject(payload) {
     return getType(payload) === 'Object';
@@ -149,6 +158,24 @@ function isEmptyString(payload) {
 function isNumber(payload) {
     return getType(payload) === 'Number' && !isNaN(payload);
 }
+/**
+ * Returns whether the payload is a positive number (but not 0)
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+function isPositiveNumber(payload) {
+    return isNumber(payload) && payload > 0;
+}
+/**
+ * Returns whether the payload is a negative number (but not 0)
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+function isNegativeNumber(payload) {
+    return isNumber(payload) && payload < 0;
+}
 /**
  * Returns whether the payload is a boolean
  *
@@ -286,11 +313,9 @@ function isPrimitive(payload) {
  * @param {*} payload
  * @returns {(payload is null | undefined)}
  */
-var isNullOrUndefined = isOneOf(isNull, isUndefined);
+const isNullOrUndefined = isOneOf(isNull, isUndefined);
 function isOneOf(a, b, c, d, e) {
-    return function (value) {
-        return a(value) || b(value) || (!!c && c(value)) || (!!d && d(value)) || (!!e && e(value));
-    };
+    return (value) => a(value) || b(value) || (!!c && c(value)) || (!!d && d(value)) || (!!e && e(value));
 }
 /**
  * Does a generic check to check that the given payload is of a given type.
@@ -311,8 +336,8 @@ function isType(payload, type) {
         throw new TypeError('Type is not a class');
     }
     // Classes usually have names (as functions usually have names)
-    var name = type.name;
+    const name = type.name;
     return getType(payload) === name || Boolean(payload && payload.constructor === type);
 }
 
-export { getType, isAnyObject, isArray, isBlob, isBoolean, isDate, isEmptyArray, isEmptyObject, isEmptyString, isError, isFile, isFullArray, isFullString, isFunction, isMap, isNaNValue, isNull, isNullOrUndefined, isNumber, isObject, isObjectLike, isOneOf, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isType, isUndefined, isWeakMap, isWeakSet };
+export { getType, isAnyObject, isArray, isBlob, isBoolean, isDate, isEmptyArray, isEmptyObject, isEmptyString, isError, isFile, isFullArray, isFullObject, isFullString, isFunction, isMap, isNaNValue, isNegativeNumber, isNull, isNullOrUndefined, isNumber, isObject, isObjectLike, isOneOf, isPlainObject, isPositiveNumber, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isType, isUndefined, isWeakMap, isWeakSet };

package/{types → dist/types}/index.d.ts

@@ -1,6 +1,7 @@
 export declare type AnyFunction = (...args: any[]) => any;
 export declare type AnyAsyncFunction = (...args: any[]) => Promise<any>;
 export declare type AnyClass = new (...args: any[]) => any;
+export declare type PlainObject = Record<string | number | symbol, any>;
 declare type TypeGuard<A, B extends A> = (payload: A) => payload is B;
 /**
  * Returns the object type of the given payload
@@ -27,16 +28,16 @@ export declare function isNull(payload: any): payload is null;
  * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
  *
  * @param {*} payload
- * @returns {payload is Record<string, any>}
+ * @returns {payload is PlainObject}
  */
-export declare function isPlainObject(payload: any): payload is Record<string, any>;
+export declare function isPlainObject(payload: any): payload is PlainObject;
 /**
  * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
  *
  * @param {*} payload
- * @returns {payload is Record<string, any>}
+ * @returns {payload is PlainObject}
  */
-export declare function isObject(payload: any): payload is Record<string, any>;
+export declare function isObject(payload: any): payload is PlainObject;
 /**
  * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
  *
@@ -46,13 +47,20 @@ export declare function isObject(payload: any): payload is Record<string, any>;
 export declare function isEmptyObject(payload: any): payload is {
     [K in any]: never;
 };
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+export declare function isFullObject(payload: any): payload is PlainObject;
 /**
  * Returns whether the payload is an any kind of object (including special classes or objects with different prototypes)
  *
  * @param {*} payload
- * @returns {payload is Record<string, any>}
+ * @returns {payload is PlainObject}
  */
-export declare function isAnyObject(payload: any): payload is Record<string, any>;
+export declare function isAnyObject(payload: any): payload is PlainObject;
 /**
  * Returns whether the payload is an object like a type passed in < >
  *
@@ -62,7 +70,7 @@ export declare function isAnyObject(payload: any): payload is Record<string, any
  * @param {*} payload
  * @returns {payload is T}
  */
-export declare function isObjectLike<T extends Record<string, any>>(payload: any): payload is T;
+export declare function isObjectLike<T extends PlainObject>(payload: any): payload is T;
 /**
  * Returns whether the payload is a function (regular or async)
  *
@@ -121,6 +129,20 @@ export declare function isEmptyString(payload: any): payload is string;
  * @returns {payload is number}
  */
 export declare function isNumber(payload: any): payload is number;
+/**
+ * Returns whether the payload is a positive number (but not 0)
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+export declare function isPositiveNumber(payload: any): payload is number;
+/**
+ * Returns whether the payload is a negative number (but not 0)
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+export declare function isNegativeNumber(payload: any): payload is number;
 /**
  * Returns whether the payload is a boolean
  *

package/package.json

@@ -1,18 +1,32 @@
 {
   "name": "is-what",
   "sideEffects": false,
-  "version": "3.14.0",
+  "type": "module",
+  "version": "4.1.1",
   "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",
-  "typings": "types/index.d.ts",
+  "module": "./dist/index.es.js",
+  "main": "./dist/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=12.13",
+    "npm": ">=7"
+  },
   "scripts": {
-    "test": "ava",
-    "jest": "jest",
-    "jest-w": "jest --watchAll",
+    "test": "vitest run",
     "lint": "tsc --noEmit src/index.ts && eslint . --ext .js,.jsx,.ts,.tsx",
     "rollup": "rollup -c ./build.js",
-    "build": "rimraf types && rimraf dist && npm run lint && npm run rollup && npm run test && npm run jest"
+    "build": "rimraf dist && npm run lint && npm run rollup && npm run test",
+    "release": "npm run build && np"
   },
   "repository": {
     "type": "git",
@@ -40,41 +54,57 @@
     "is-plain-object"
   ],
   "author": "Luca Ban - Mesqueeb",
+  "funding": "https://github.com/sponsors/mesqueeb",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/mesqueeb/is-what/issues"
   },
   "homepage": "https://github.com/mesqueeb/is-what#readme",
   "devDependencies": {
-    "@babel/core": "^7.12.17",
-    "@types/babel-core": "^6.25.6",
-    "@types/jest": "^26.0.20",
-    "@typescript-eslint/eslint-plugin": "^4.15.1",
-    "@typescript-eslint/parser": "^4.15.1",
-    "ava": "^3.15.0",
-    "babel-core": "^7.0.0-bridge.0",
-    "babel-jest": "^26.6.3",
-    "babel-preset-env": "^1.7.0",
-    "eslint": "^7.20.0",
-    "eslint-config-prettier": "^7.2.0",
-    "eslint-plugin-tree-shaking": "^1.8.0",
-    "jest": "^26.6.3",
-    "prettier": "^2.2.1",
-    "regenerator-runtime": "^0.13.7",
+    "@typescript-eslint/eslint-plugin": "^5.10.0",
+    "@typescript-eslint/parser": "^5.10.0",
+    "eslint": "^8.7.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-tree-shaking": "^1.10.0",
+    "np": "^7.6.0",
+    "prettier": "^2.5.1",
     "rimraf": "^3.0.2",
-    "rollup": "^2.39.0",
-    "rollup-plugin-typescript2": "^0.30.0",
-    "ts-node": "^9.1.1",
-    "tsconfig-paths": "^3.9.0",
-    "typescript": "^4.1.5"
+    "rollup": "^2.66.0",
+    "rollup-plugin-typescript2": "^0.31.1",
+    "typescript": "^4.5.5",
+    "vitest": "^0.2.1"
   },
   "ava": {
-    "extensions": [
-      "ts"
-    ],
-    "require": [
-      "tsconfig-paths/register",
-      "ts-node/register"
+    "extensions": {
+      "ts": "module"
+    },
+    "nodeArguments": [
+      "--loader=ts-node/esm"
     ]
+  },
+  "np": {
+    "yarn": false,
+    "branch": "production"
+  },
+  "eslintConfig": {
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+      "@typescript-eslint",
+      "tree-shaking"
+    ],
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:@typescript-eslint/recommended",
+      "prettier"
+    ],
+    "rules": {
+      "@typescript-eslint/no-empty-function": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/ban-ts-ignore": "off",
+      "tree-shaking/no-side-effects-in-initialization": "error",
+      "@typescript-eslint/explicit-module-boundary-types": "off"
+    }
   }
 }

package/.babelrc

@@ -1,3 +0,0 @@
-{
-  "presets": ["env"]
-}

package/.eslintignore

@@ -1,9 +0,0 @@
-# don't ever lint node_modules
-node_modules
-# don't lint build output (make sure it's set to your correct build folder name)
-dist
-# don't lint nyc coverage output
-coverage
-
-test
-.eslintrc.js