is-what - npm Package Compare versions

Comparing version 2.2.0 to 2.3.0

dist/index.cjs.js

@@ -5,35 +5,157 @@ 'use strict';
 
+/**
+ * Returns the object type of the given payload
+ *
+ * @param {*} payload
+ * @returns {string}
+ */
 function getType(payload) {
     return Object.prototype.toString.call(payload).slice(8, -1);
 }
+/**
+ * Returns whether the payload is undefined
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
 function isUndefined(payload) {
     return getType(payload) === 'Undefined';
 }
+/**
+ * Returns whether the payload is null
+ *
+ * @param {*} payload
+ * @returns {payload is null}
+ */
 function isNull(payload) {
     return getType(payload) === 'Null';
 }
+/**
+ * Returns whether the payload is an object
+ *
+ * @param {*} payload
+ * @returns {payload is object}
+ */
 function isObject(payload) {
     return getType(payload) === 'Object';
 }
+/**
+ * Returns whether the payload is a function
+ *
+ * @param {*} payload
+ * @returns {payload is Function}
+ */
 function isFunction(payload) {
     return getType(payload) === 'Function';
 }
+/**
+ * Returns whether the payload is an array
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
 function isArray(payload) {
     return getType(payload) === 'Array';
 }
+/**
+ * Returns whether the payload is a string
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
 function isString(payload) {
     return getType(payload) === 'String';
 }
+/**
+ * Returns whether the payload is a number
+ *
+ * This will return false for NaN
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
 function isNumber(payload) {
     return (getType(payload) === 'Number' && !isNaN(payload));
 }
+/**
+ * Returns whether the payload is a boolean
+ *
+ * @param {*} payload
+ * @returns {payload is boolean}
+ */
 function isBoolean(payload) {
     return getType(payload) === 'Boolean';
 }
+/**
+ * Returns whether the payload is a regular expression
+ *
+ * @param {*} payload
+ * @returns {payload is RegExp}
+ */
 function isRegExp(payload) {
     return getType(payload) === 'RegExp';
 }
+/**
+ * Returns whether the payload is a date, and that the date is Valid
+ *
+ * @param {*} payload
+ * @returns {payload is Date}
+ */
 function isDate(payload) {
     return (getType(payload) === 'Date' && !isNaN(payload));
 }
+/**
+ * Returns whether the payload is a Symbol
+ *
+ * @param {*} payload
+ * @returns {payload is Symbol}
+ */
+function isSymbol(payload) {
+    return (getType(payload) === 'Symbol');
+}
+/**
+ * Returns whether the payload is a Class
+ *
+ * @param {*} payload
+ * @returns {payload is }
+ */
+// export function isClass (payload: any): payload is Object {
+//   return (getType(payload) === '')
+// }
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
+ *
+ * @param {*} payload
+ * @returns {*}
+ */
+function isPrimitive(payload) {
+    return (isBoolean(payload) ||
+        isNull(payload) ||
+        isUndefined(payload) ||
+        isNumber(payload) ||
+        isString(payload) ||
+        isSymbol(payload));
+}
+/**
+ * Does a generic check to check that the given payload is of a given type.
+ * In cases like Number, it will return true for NaN as NaN is a Number (thanks javascript!);
+ * It will, however, differentiate between object and null
+ *
+ * @template T
+ * @param {*} payload
+ * @param {T} type
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ * @returns {payload is T}
+ */
+function isType(payload, type) {
+    if (!(type instanceof Function)) {
+        throw new TypeError('Type must be a function');
+    }
+    if (!type.hasOwnProperty('prototype')) {
+        throw new TypeError('Type is not a class');
+    }
+    // Classes usually have names (as functions usually have names)
+    var name = type.name;
+    return (getType(payload) === name) || Boolean(payload && (payload.constructor === type));
+}
 
@@ -51,1 +173,4 @@ exports.getType = getType;
 exports.isDate = isDate;
+exports.isSymbol = isSymbol;
+exports.isPrimitive = isPrimitive;
+exports.isType = isType;

dist/index.esm.js

@@ -0,35 +1,157 @@
+/**
+ * Returns the object type of the given payload
+ *
+ * @param {*} payload
+ * @returns {string}
+ */
 function getType(payload) {
     return Object.prototype.toString.call(payload).slice(8, -1);
 }
+/**
+ * Returns whether the payload is undefined
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
 function isUndefined(payload) {
     return getType(payload) === 'Undefined';
 }
+/**
+ * Returns whether the payload is null
+ *
+ * @param {*} payload
+ * @returns {payload is null}
+ */
 function isNull(payload) {
     return getType(payload) === 'Null';
 }
+/**
+ * Returns whether the payload is an object
+ *
+ * @param {*} payload
+ * @returns {payload is object}
+ */
 function isObject(payload) {
     return getType(payload) === 'Object';
 }
+/**
+ * Returns whether the payload is a function
+ *
+ * @param {*} payload
+ * @returns {payload is Function}
+ */
 function isFunction(payload) {
     return getType(payload) === 'Function';
 }
+/**
+ * Returns whether the payload is an array
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
 function isArray(payload) {
     return getType(payload) === 'Array';
 }
+/**
+ * Returns whether the payload is a string
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
 function isString(payload) {
     return getType(payload) === 'String';
 }
+/**
+ * Returns whether the payload is a number
+ *
+ * This will return false for NaN
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
 function isNumber(payload) {
     return (getType(payload) === 'Number' && !isNaN(payload));
 }
+/**
+ * Returns whether the payload is a boolean
+ *
+ * @param {*} payload
+ * @returns {payload is boolean}
+ */
 function isBoolean(payload) {
     return getType(payload) === 'Boolean';
 }
+/**
+ * Returns whether the payload is a regular expression
+ *
+ * @param {*} payload
+ * @returns {payload is RegExp}
+ */
 function isRegExp(payload) {
     return getType(payload) === 'RegExp';
 }
+/**
+ * Returns whether the payload is a date, and that the date is Valid
+ *
+ * @param {*} payload
+ * @returns {payload is Date}
+ */
 function isDate(payload) {
     return (getType(payload) === 'Date' && !isNaN(payload));
 }
+/**
+ * Returns whether the payload is a Symbol
+ *
+ * @param {*} payload
+ * @returns {payload is Symbol}
+ */
+function isSymbol(payload) {
+    return (getType(payload) === 'Symbol');
+}
+/**
+ * Returns whether the payload is a Class
+ *
+ * @param {*} payload
+ * @returns {payload is }
+ */
+// export function isClass (payload: any): payload is Object {
+//   return (getType(payload) === '')
+// }
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
+ *
+ * @param {*} payload
+ * @returns {*}
+ */
+function isPrimitive(payload) {
+    return (isBoolean(payload) ||
+        isNull(payload) ||
+        isUndefined(payload) ||
+        isNumber(payload) ||
+        isString(payload) ||
+        isSymbol(payload));
+}
+/**
+ * Does a generic check to check that the given payload is of a given type.
+ * In cases like Number, it will return true for NaN as NaN is a Number (thanks javascript!);
+ * It will, however, differentiate between object and null
+ *
+ * @template T
+ * @param {*} payload
+ * @param {T} type
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ * @returns {payload is T}
+ */
+function isType(payload, type) {
+    if (!(type instanceof Function)) {
+        throw new TypeError('Type must be a function');
+    }
+    if (!type.hasOwnProperty('prototype')) {
+        throw new TypeError('Type is not a class');
+    }
+    // Classes usually have names (as functions usually have names)
+    var name = type.name;
+    return (getType(payload) === name) || Boolean(payload && (payload.constructor === type));
+}
 
-export { getType, isUndefined, isNull, isObject, isFunction, isArray, isString, isNumber, isBoolean, isRegExp, isDate };
+export { getType, isUndefined, isNull, isObject, isFunction, isArray, isString, isNumber, isBoolean, isRegExp, isDate, isSymbol, isPrimitive, isType };

package.json

 {
   "name": "is-what",
-  "version": "2.2.0",
-  "description": "JS type check functions like `isObject() isArray()` etc. A simple & small integration.",
+  "version": "2.3.0",
+  "description": "JS type check (TypeScript supported) functions like `isObject() isArray()` etc. A simple & small integration.",
   "main": "dist/index.cjs.js",
@@ -9,3 +9,4 @@ "module": "dist/index.esm.js",
   "scripts": {
-    "test": "ava",
+    "test": "jest",
+    "test-w": "jest --watchAll",
     "build": "rollup -c ./build/rollup.js && npm run test"
@@ -19,2 +20,3 @@ },
     "javascript",
+    "typescript",
     "typechecker",
@@ -30,3 +32,10 @@ "check-type"
   "devDependencies": {
-    "ava": "1.0.0-beta.8",
+    "@babel/core": "^7.1.0",
+    "@types/babel-core": "^6.25.5",
+    "@types/jest": "^23.3.2",
+    "babel-core": "^7.0.0-bridge.0",
+    "babel-jest": "^23.6.0",
+    "babel-preset-env": "^1.7.0",
+    "jest": "^23.6.0",
+    "regenerator-runtime": "^0.12.1",
     "rollup": "^0.65.2",
@@ -33,0 +42,0 @@ "rollup-plugin-typescript2": "^0.17.0",

README.md

@@ -1,2 +0,2 @@
-# is What?
+# is What? 🙉
 
@@ -7,6 +7,44 @@ ```
 
-Very simple & small JS type check function
+Very simple & small JS type check functions. It's fully TypeScript supported!
 
 **Motivation:** I built is-what because the existing solutions were all too complex.
 
+### Functions
+
+isString, isNumber, isBoolean, isObject, isFunction, isArray, isUndefined, isNull, isRegExp, isDate, isSymbol, isPrimitive, isType, getType
+
+### Usage
+
+is-what is really easy to use, and all functions above work just like you'd expect.
+
+```js
+import { isString, isType, getType } from 'is-what'
+
+isString('') // returns true
+isType('', String) // returns true
+getType('') // returns 'String'
+```
+
+**Exception:**<br>
+Checking for `isNumber` and `isDate` will return `false` if the payload is `NaN` or an invalid date.
+
+```js
+isNumber(NaN) // returns false
+isDate(new Date('---- invalid date ----')) // returns false
+```
+
+### TypeScript usage example:
+
+```TypeScript
+// is-what makes TypeScript know the type during if statements:
+function fn (payload: string | number): number {
+  if (isNumber(payload)) {
+    // ↑ TypeScript already knows payload is a number here!
+    return payload
+  }
+}
+```
+
+### Source code
+
 It's litterally just these functions:
@@ -21,4 +59,4 @@
 }
-function isNull (payload) {
-  return getType(payload) === 'Null'
+function isString (payload) {
+  return getType(payload) === 'String'
 }
@@ -28,26 +66,6 @@ function isObject (payload) {
 }
-function isFunction (payload) {
-  return getType(payload) === 'Function'
-}
-function isArray (payload) {
-  return getType(payload) === 'Array'
-}
-function isString (payload) {
-  return getType(payload) === 'String'
-}
-function isNumber (payload) {
-  return (getType(payload) === 'Number' && !isNaN(payload))
-}
-function isBoolean (payload) {
-  return getType(payload) === 'Boolean'
-}
-function isRegExp (payload) {
-  return getType(payload) === 'RegExp'
-}
-function isDate (payload) {
-  return (getType(payload) === 'Date' &&  !isNaN(payload))
-}
+// etc...
 ```
 
-Since v2.0.0, checking for `isNumber` and `isDate` will return `false` if the payload is `NaN` or an invalid date.
+See the full source code [here](https://github.com/mesqueeb/is-what/blob/master/src/index.ts).
 
@@ -54,0 +72,0 @@ ## Tests

src/index.ts

 
-function getType (payload: any): string {
+/**
+ * Returns the object type of the given payload
+ *
+ * @param {*} payload
+ * @returns {string}
+ */
+export function getType (payload: any): string {
   return Object.prototype.toString.call(payload).slice(8, -1)
 }
-function isUndefined (payload: any): payload is undefined {
+
+/**
+ * Returns whether the payload is undefined
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
+export function isUndefined (payload: any): payload is undefined {
   return getType(payload) === 'Undefined'
 }
-function isNull (payload: any): payload is null {
+
+/**
+ * Returns whether the payload is null
+ *
+ * @param {*} payload
+ * @returns {payload is null}
+ */
+export function isNull (payload: any): payload is null {
   return getType(payload) === 'Null'
 }
-function isObject (payload: any): payload is object {
+
+/**
+ * Returns whether the payload is an object
+ *
+ * @param {*} payload
+ * @returns {payload is object}
+ */
+export function isObject (payload: any): payload is object {
   return getType(payload) === 'Object'
 }
-function isFunction (payload: any): payload is Function {
+
+/**
+ * Returns whether the payload is a function
+ *
+ * @param {*} payload
+ * @returns {payload is Function}
+ */
+export function isFunction (payload: any): payload is Function {
   return getType(payload) === 'Function'
 }
-function isArray (payload: any): payload is any[] {
+
+/**
+ * Returns whether the payload is an array
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
+export function isArray (payload: any): payload is any[] {
   return getType(payload) === 'Array'
 }
-function isString (payload: any): payload is string {
+
+/**
+ * Returns whether the payload is a string
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
+export function isString (payload: any): payload is string {
   return getType(payload) === 'String'
 }
-function isNumber (payload: any): payload is number {
+
+/**
+ * Returns whether the payload is a number
+ *
+ * This will return false for NaN
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+export function isNumber (payload: any): payload is number {
   return (getType(payload) === 'Number' && !isNaN(payload))
 }
-function isBoolean (payload: any): payload is boolean {
+
+/**
+ * Returns whether the payload is a boolean
+ *
+ * @param {*} payload
+ * @returns {payload is boolean}
+ */
+export function isBoolean (payload: any): payload is boolean {
   return getType(payload) === 'Boolean'
 }
-function isRegExp (payload: any): payload is RegExp {
+
+/**
+ * Returns whether the payload is a regular expression
+ *
+ * @param {*} payload
+ * @returns {payload is RegExp}
+ */
+export function isRegExp (payload: any): payload is RegExp {
   return getType(payload) === 'RegExp'
 }
-function isDate (payload: any): payload is Date {
+
+/**
+ * Returns whether the payload is a date, and that the date is Valid
+ *
+ * @param {*} payload
+ * @returns {payload is Date}
+ */
+export function isDate (payload: any): payload is Date {
   return (getType(payload) === 'Date' && !isNaN(payload))
 }
 
-export {
-  getType,
-  isUndefined,
-  isNull,
-  isObject,
-  isFunction,
-  isArray,
-  isString,
-  isNumber,
-  isBoolean,
-  isRegExp,
-  isDate
+/**
+ * Returns whether the payload is a Symbol
+ *
+ * @param {*} payload
+ * @returns {payload is Symbol}
+ */
+export function isSymbol (payload: any): payload is Symbol {
+  return (getType(payload) === 'Symbol')
 }
+
+/**
+ * Returns whether the payload is a Class
+ *
+ * @param {*} payload
+ * @returns {payload is }
+ */
+// export function isClass (payload: any): payload is Object {
+//   return (getType(payload) === '')
+// }
+
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
+ *
+ * @param {*} payload
+ * @returns {*}
+ */
+export function isPrimitive (payload: any): any {
+  return (
+    isBoolean(payload) ||
+    isNull(payload) ||
+    isUndefined(payload) ||
+    isNumber(payload) ||
+    isString(payload) ||
+    isSymbol(payload)
+  )
+}
+
+/**
+ * Does a generic check to check that the given payload is of a given type.
+ * In cases like Number, it will return true for NaN as NaN is a Number (thanks javascript!);
+ * It will, however, differentiate between object and null
+ *
+ * @template T
+ * @param {*} payload
+ * @param {T} type
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ * @returns {payload is T}
+ */
+export function isType<T extends Function> (payload: any, type: T): payload is T {
+  if (!(type instanceof Function)) {
+    throw new TypeError('Type must be a function')
+  }
+  if (!type.hasOwnProperty('prototype')) {
+    throw new TypeError('Type is not a class')
+  }
+  // Classes usually have names (as functions usually have names)
+  const name: string | undefined | null = (<any>type).name
+  return (getType(payload) === name) || Boolean(payload && (payload.constructor === type))
+}

types/index.d.ts

@@ -1,12 +0,111 @@
-declare function getType(payload: any): string;
-declare function isUndefined(payload: any): payload is undefined;
-declare function isNull(payload: any): payload is null;
-declare function isObject(payload: any): payload is object;
-declare function isFunction(payload: any): payload is Function;
-declare function isArray(payload: any): payload is any[];
-declare function isString(payload: any): payload is string;
-declare function isNumber(payload: any): payload is number;
-declare function isBoolean(payload: any): payload is boolean;
-declare function isRegExp(payload: any): payload is RegExp;
-declare function isDate(payload: any): payload is Date;
-export { getType, isUndefined, isNull, isObject, isFunction, isArray, isString, isNumber, isBoolean, isRegExp, isDate };
+/**
+ * Returns the object type of the given payload
+ *
+ * @param {*} payload
+ * @returns {string}
+ */
+export declare function getType(payload: any): string;
+/**
+ * Returns whether the payload is undefined
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
+export declare function isUndefined(payload: any): payload is undefined;
+/**
+ * Returns whether the payload is null
+ *
+ * @param {*} payload
+ * @returns {payload is null}
+ */
+export declare function isNull(payload: any): payload is null;
+/**
+ * Returns whether the payload is an object
+ *
+ * @param {*} payload
+ * @returns {payload is object}
+ */
+export declare function isObject(payload: any): payload is object;
+/**
+ * Returns whether the payload is a function
+ *
+ * @param {*} payload
+ * @returns {payload is Function}
+ */
+export declare function isFunction(payload: any): payload is Function;
+/**
+ * Returns whether the payload is an array
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
+export declare function isArray(payload: any): payload is any[];
+/**
+ * Returns whether the payload is a string
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
+export declare function isString(payload: any): payload is string;
+/**
+ * Returns whether the payload is a number
+ *
+ * This will return false for NaN
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+export declare function isNumber(payload: any): payload is number;
+/**
+ * Returns whether the payload is a boolean
+ *
+ * @param {*} payload
+ * @returns {payload is boolean}
+ */
+export declare function isBoolean(payload: any): payload is boolean;
+/**
+ * Returns whether the payload is a regular expression
+ *
+ * @param {*} payload
+ * @returns {payload is RegExp}
+ */
+export declare function isRegExp(payload: any): payload is RegExp;
+/**
+ * Returns whether the payload is a date, and that the date is Valid
+ *
+ * @param {*} payload
+ * @returns {payload is Date}
+ */
+export declare function isDate(payload: any): payload is Date;
+/**
+ * Returns whether the payload is a Symbol
+ *
+ * @param {*} payload
+ * @returns {payload is Symbol}
+ */
+export declare function isSymbol(payload: any): payload is Symbol;
+/**
+ * Returns whether the payload is a Class
+ *
+ * @param {*} payload
+ * @returns {payload is }
+ */
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
+ *
+ * @param {*} payload
+ * @returns {*}
+ */
+export declare function isPrimitive(payload: any): any;
+/**
+ * Does a generic check to check that the given payload is of a given type.
+ * In cases like Number, it will return true for NaN as NaN is a Number (thanks javascript!);
+ * It will, however, differentiate between object and null
+ *
+ * @template T
+ * @param {*} payload
+ * @param {T} type
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ * @returns {payload is T}
+ */
+export declare function isType<T extends Function>(payload: any, type: T): payload is T;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

25879

increased by139.07%

Number of package files

12

increased by20%

Lines of code

785

increased by224.38%

Number of lines in readme file

74

increased by32.14%

Worsened metrics

Dev dependency count

11

increased by175%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes