is-what 3.14.1 → 4.1.2

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}

@@ -162,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
  *
@@ -299,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.
@@ -324,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);
 }
 
@@ -345,6 +361,7 @@ exports.isFullString = isFullString;
 exports.isFunction = isFunction;
 exports.isMap = isMap;
 exports.isNaNValue = isNaNValue;
+exports.isNegativeNumber = isNegativeNumber;
 exports.isNull = isNull;
 exports.isNullOrUndefined = isNullOrUndefined;
 exports.isNumber = isNumber;
@@ -352,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}

@@ -158,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
  *
@@ -295,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.
@@ -320,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, isFullObject, 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

@@ -129,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,19 +1,31 @@
 {
   "name": "is-what",
   "sideEffects": false,
-  "version": "3.14.1",
+  "type": "module",
+  "version": "4.1.2",
   "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",
-    "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",
-    "release": "npm run build && np"
+    "test": "vitest run",
+    "lint": "tsc --noEmit ./src/index.ts && eslint ./src --ext .ts",
+    "build": "rollup -c ./scripts/build.js",
+    "release": "npm run lint && del dist && npm run build && np"
   },
   "repository": {
     "type": "git",
@@ -41,46 +53,63 @@
     "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",
-    "np": "^7.4.0",
-    "prettier": "^2.2.1",
-    "regenerator-runtime": "^0.13.7",
-    "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"
+    "@typescript-eslint/eslint-plugin": "^5.10.1",
+    "@typescript-eslint/parser": "^5.10.1",
+    "del-cli": "^4.0.1",
+    "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",
+    "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": {
+    "ignorePatterns": [
+      "node_modules",
+      "dist",
+      "scripts",
+      "test"
+    ],
+    "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/ban-ts-comment": "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

package/.eslintrc.js

@@ -1,18 +0,0 @@
-// npm i -D @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint eslint-config-prettier eslint-plugin-tree-shaking
-module.exports = {
-  root: true,
-  parser: '@typescript-eslint/parser',
-  plugins: ['@typescript-eslint', 'tree-shaking'],
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/eslint-recommended',
-    'plugin:@typescript-eslint/recommended',
-    'prettier/@typescript-eslint',
-  ],
-  rules: {
-    '@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/.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: mesqueeb
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/.prettierrc

@@ -1,9 +0,0 @@
-{
-  "printWidth": 100,
-  "tabWidth": 2,
-  "singleQuote": true,
-  "trailingComma": "es5",
-  "semi": false,
-  "bracketSpacing": true,
-  "quoteProps": "consistent"
-}

package/.vscode/settings.json

@@ -1,9 +0,0 @@
-{
-  "editor.formatOnSave": true,
-  "editor.defaultFormatter": "esbenp.prettier-vscode",
-  "editor.tabSize": 2, // make sure this is the same as .prettierrc
-  "editor.insertSpaces": true,
-  "files.insertFinalNewline": true,
-  "files.trimFinalNewlines": true,
-  "files.trimTrailingWhitespace": true
-}

package/build.js

@@ -1,60 +0,0 @@
-/* eslint-disable */
-
-// npm install rollup-plugin-typescript2 typescript --save-dev
-import typescript from 'rollup-plugin-typescript2'
-// import { terser } from 'rollup-plugin-terser'
-// import resolve from 'rollup-plugin-node-resolve'
-
-// ------------------------------------------------------------------------------------------
-// formats
-// ------------------------------------------------------------------------------------------
-// amd – Asynchronous Module Definition, used with module loaders like RequireJS
-// cjs – CommonJS, suitable for Node and Browserify/Webpack
-// esm – Keep the bundle as an ES module file
-// iife – A self-executing function, suitable for inclusion as a <script> tag. (If you want to create a bundle for your application, you probably want to use this, because it leads to smaller file sizes.)
-// umd – Universal Module Definition, works as amd, cjs and iife all in one
-// system – Native format of the SystemJS loader
-
-// ------------------------------------------------------------------------------------------
-// setup
-// ------------------------------------------------------------------------------------------
-const pkg = require('./package.json')
-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, tsconfigOverride: { exclude: ['test/**/*'] } }),
-]
-
-// ------------------------------------------------------------------------------------------
-// Builds
-// ------------------------------------------------------------------------------------------
-function defaults (config) {
-  // defaults
-  const defaults = {
-    plugins,
-    external,
-  }
-  // defaults.output
-  config.output = config.output.map(output => {
-    return Object.assign(
-      {
-        sourcemap: false,
-        name: className,
-        exports: 'named',
-      },
-      output
-    )
-  })
-  return Object.assign(defaults, config)
-}
-
-export default [
-  defaults({
-    input: 'src/index.ts',
-    output: [
-      { file: 'dist/index.cjs.js', format: 'cjs' },
-      { file: 'dist/index.esm.js', format: 'esm' },
-    ],
-  }),
-]