is-what 4.1.0 → 4.1.4

package/test/ava.ts

@@ -1,419 +0,0 @@
-import test from 'ava'
-
-import {
-  isError,
-  isEmptyArray,
-  isObject,
-  isPlainObject,
-  isAnyObject,
-  isUndefined,
-  isNull,
-  isNullOrUndefined,
-  isFunction,
-  isArray,
-  isString,
-  isEmptyString,
-  isFullString,
-  isBoolean,
-  isRegExp,
-  isNumber,
-  isPositiveNumber,
-  isNegativeNumber,
-  isDate,
-  isSymbol,
-  isPrimitive,
-  isType,
-  isMap,
-  isWeakMap,
-  isSet,
-  isWeakSet,
-  isFullArray,
-  // isBlob,
-  // isFile,
-  isPromise,
-  isNaNValue,
-  isEmptyObject,
-  isOneOf,
-  isFullObject,
-} from '../src/index.js'
-
-// TODO: test isBlob
-// test('isBlob', () => {
-//   expect(isBlob(Blob)).toBe(false)
-//   expect(isBlob(new Blob())).toBe(true)
-// })
-
-// TODO: test isFile
-// test('isFile', () => {
-//   expect(isFile(File)).toBe(false)
-//   expect(isFile(new File([''], '', { type: 'text/html' }))).toBe(true)
-// })
-
-test('Basic true tests', (t: any) => {
-  t.is(isError(new Error('')), true)
-  t.is(isUndefined(undefined), true)
-  t.is(isNull(null), true)
-  t.is(isNullOrUndefined(null), true)
-  t.is(isNullOrUndefined(undefined), true)
-  t.is(isObject({}), true)
-  t.is(isEmptyObject({}), true)
-  t.is(isFullObject({ 0: '' }), true)
-  t.is(isFullObject({ '': '' }), true)
-  t.is(isObject(new Object()), true)
-  t.is(isArray([]), true)
-  t.is(isEmptyArray([]), true)
-  t.is(isFullArray(['']), true)
-  t.is(isArray(new Array()), true)
-  t.is(isString(''), true)
-  t.is(isString('_'), true)
-  t.is(isEmptyString(''), true)
-  t.is(isFullString(' '), true)
-  t.is(isBoolean(true), true)
-  t.is(isBoolean(false), true)
-  t.is(isRegExp(/./), true)
-  t.is(isRegExp(/./gi), true)
-  t.is(isNumber(0), true)
-  t.is(isNumber(1), true)
-  t.is(isDate(new Date()), true)
-  t.is(isSymbol(Symbol()), true)
-  t.is(isMap(new Map()), true)
-  t.is(isWeakMap(new WeakMap()), true)
-  t.is(isSet(new Set()), true)
-  t.is(isWeakSet(new WeakSet()), true)
-  // t.is(isBlob(blob), true)
-  // t.is(isFile(new File([''], '', { type: 'text/html' })), true)
-  t.is(isPromise(new Promise((resolve, reject) => {})), true)
-})
-
-test('Basic false tests', (t: any) => {
-  t.is(isError({}), false)
-  t.is(isNumber(NaN), false)
-  t.is(isDate(new Date('_')), false)
-  t.is(isDate(NaN), false)
-  t.is(isUndefined(NaN), false)
-  t.is(isNull(NaN), false)
-  t.is(isObject(NaN), false)
-  t.is(isArray(NaN), false)
-  t.is(isString(NaN), false)
-  t.is(isEmptyString(' '), false)
-  t.is(isFullString(''), false)
-  t.is(isBoolean(NaN), false)
-  t.is(isRegExp(NaN), false)
-  t.is(isSymbol(NaN), false)
-  t.is(isMap(new WeakMap()), false)
-  t.is(isWeakMap(new Map()), false)
-  t.is(isSet(new WeakSet()), false)
-  t.is(isWeakSet(new Set()), false)
-  t.is(isNullOrUndefined(NaN), false)
-})
-
-test('isFunction', (t: any) => {
-  t.is(isFunction(NaN), false)
-  t.is(
-    isFunction(() => {}),
-    true
-  )
-  t.is(
-    isFunction(function () {}),
-    true
-  )
-  t.is(
-    isFunction(async () => {}),
-    true
-  )
-  t.is(
-    isFunction(async function () {}),
-    true
-  )
-  t.is(
-    isFunction(function* () {}),
-    true
-  )
-  t.is(
-    isFunction(async function* () {}),
-    true
-  )
-  const _ = { fn: () => {}, method() {} }
-  t.is(isFunction(_.fn), true)
-  t.is(isFunction(_.method), true)
-})
-
-test('isEmptyObject', (t: any) => {
-  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: any) => {
-  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('isFullArray', (t: any) => {
-  t.is(isFullArray(new Array(1)), true)
-  t.is(isFullArray([undefined]), true)
-  t.is(isFullArray([null]), true)
-  t.is(isFullArray(['']), true)
-
-  t.is(isFullArray([]), false)
-  t.is(isFullArray(new Array()), false)
-  t.is(isFullArray(new Array(0)), false)
-
-  t.is(isFullArray(null), false)
-  t.is(isFullArray(new Date()), false)
-  t.is(isFullArray(new Error('')), false)
-  t.is(isFullArray(new Date()), false)
-  t.is(isFullArray(Symbol()), false)
-  t.is(isFullArray(new Map()), false)
-  t.is(isFullArray(new WeakMap()), false)
-  t.is(isFullArray(new Set()), false)
-  t.is(isFullArray(new WeakSet()), false)
-})
-
-test('isPositiveNumber / isNegativeNumber', (t: any) => {
-  t.is(isPositiveNumber(-1), false)
-  t.is(isPositiveNumber(0), false)
-  t.is(isPositiveNumber(1), true)
-  t.is(isNegativeNumber(-1), true)
-  t.is(isNegativeNumber(0), false)
-  t.is(isNegativeNumber(1), false)
-})
-
-test('NaN tests', (t: any) => {
-  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: any) => {
-  // true
-  t.is(isPrimitive(0), true)
-  t.is(isPrimitive(''), true)
-  t.is(isPrimitive('str'), true)
-  t.is(isPrimitive(Symbol()), true)
-  t.is(isPrimitive(true), true)
-  t.is(isPrimitive(false), true)
-  t.is(isPrimitive(null), true)
-  t.is(isPrimitive(undefined), true)
-  // false
-  t.is(isPrimitive(NaN), false)
-  t.is(isPrimitive([]), false)
-  t.is(isPrimitive(new Array()), false)
-  t.is(isPrimitive({}), false)
-  t.is(isPrimitive(new Object()), false)
-  t.is(isPrimitive(new Date()), false)
-  t.is(
-    isPrimitive(() => {}),
-    false
-  )
-})
-
-test('Date exception', (t: any) => {
-  t.is(isDate(new Date('_')), false)
-})
-
-test('Generic isType', (t: any) => {
-  // -----------------------------
-  // This is correct old fashion syntax for classes, if this is missing
-  function MyClass() {}
-  MyClass.prototype.constructor = MyClass
-  // @ts-ignore
-  const myClass = new MyClass()
-  // -----------------------------
-  class MyOtherClass {
-    constructor() {}
-  }
-  // this is expected behaviour
-  t.is(isType('', String), true)
-  t.is(isType('_', String), true)
-  t.is(isType('Hello World', String), true)
-  t.is(isType(NaN, Number), true)
-  t.is(isType(0, Number), true)
-  t.is(isType(1, Number), true)
-  t.is(isType({}, Object), true)
-  t.is(isType(new Object(), Object), true)
-  t.is(isType([], Array), true)
-  t.is(isType(new Array(), Array), true)
-  t.is(
-    isType(() => {}, Function),
-    true
-  )
-  t.is(isType(true, Boolean), true)
-  t.is(isType(false, Boolean), true)
-  t.is(isType(new Date('_'), Date), true)
-  t.is(isType(new Date(), Date), true)
-  t.is(isType(/./, RegExp), true)
-  t.is(isType(/./gi, RegExp), true)
-  t.is(isType(myClass, MyClass), true)
-  t.is(isType(new MyOtherClass(), MyOtherClass), true)
-  t.is(isType(myClass, MyOtherClass), false)
-  t.is(isType(Symbol(), Symbol), true)
-  // t.is(isType(null, Null), true)
-  // t.is(isType(undefined, Undefined), true)
-  // It SHOULD fail
-  t.is(isType(5, String), false)
-  t.is(isType(null, Object), false)
-  // Not sure if this would be the expected behaviour but everything is an object
-  // so I would say so
-  t.is(isType(myClass, Object), true)
-})
-
-test('isObject vs isAnyObject', (t: any) => {
-  // -----------------------------
-  // This is correct old fashion syntax for classes, if this is missing
-  function MyClass() {}
-  MyClass.prototype.constructor = MyClass
-  // @ts-ignore
-  const myClass = new MyClass()
-  // -----------------------------
-  class MyClass2 {
-    constructor() {}
-  }
-  const myClass2 = new MyClass2()
-  const mySpecialObject = {}
-  Object.setPrototypeOf(mySpecialObject, {
-    toDate: function () {
-      return new Date()
-    },
-  })
-  // IS OBJECT
-  // plain object
-  t.is(isObject({}), true)
-  t.is(isObject(new Object()), true)
-  t.is(isPlainObject({}), true)
-  t.is(isPlainObject(new Object()), true)
-  // classes & prototypes
-  t.is(isObject(myClass), false)
-  t.is(isObject(myClass2), false)
-  t.is(isObject(mySpecialObject), false)
-  t.is(isPlainObject(myClass), false)
-  t.is(isPlainObject(myClass2), false)
-  t.is(isPlainObject(mySpecialObject), false)
-  // arrays and dates
-  t.is(isObject([]), false)
-  t.is(isObject(new Array()), false)
-  t.is(isObject(new Date('_')), false)
-  t.is(isObject(new Date()), false)
-  t.is(isPlainObject([]), false)
-  t.is(isPlainObject(new Array()), false)
-  t.is(isPlainObject(new Date('_')), false)
-  t.is(isPlainObject(new Date()), false)
-  // IS ANY OBJECT
-  // plain object
-  t.is(isAnyObject({}), true)
-  t.is(isAnyObject(new Object()), true)
-  // classes & prototypes
-  t.is(isAnyObject(myClass), true)
-  t.is(isAnyObject(myClass2), true)
-  t.is(isAnyObject(mySpecialObject), true)
-  // arrays and dates
-  t.is(isAnyObject([]), false)
-  t.is(isAnyObject(new Array()), false)
-  t.is(isAnyObject(new Date('_')), false)
-  t.is(isAnyObject(new Date()), false)
-})
-
-test('isOneOf', (t: any) => {
-  t.is(isOneOf(isString, isNumber)('_'), true)
-  t.is(isOneOf(isString, isNumber)(1), true)
-  t.is(isOneOf(isString, isNumber)(undefined), false)
-
-  t.is(isOneOf(isString, isNumber, isBoolean)('_'), true)
-  t.is(isOneOf(isString, isNumber, isBoolean)(1), true)
-  t.is(isOneOf(isString, isNumber, isBoolean)(true), true)
-  t.is(isOneOf(isString, isNumber, isBoolean)(undefined), false)
-
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)('_'), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)(1), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)(true), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)([]), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)(undefined), false)
-
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)('_'), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)(1), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)(true), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)([]), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)({}), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)(undefined), false)
-})
-
-test('type related tests', (t: any) => {
-  t.pass()
-  // const fn: string | ((k: number) => string) = (p) => 'a'
-  // if (!isFunction(fn)) {
-  //   fn
-  // }
-
-  // const a: Record<string, number> = {}
-
-  // a[fn(1)] = fn(2)
-
-  // const myArray: string | string[] = ['a', 'b']
-  // if (!isArray(myArray)) {
-  //   myArray
-  // }
-
-  // const a: Record<string, number> = {}
-
-  // a[myArray[1]] = myArray[0]
-
-  // const myArray: string | any[] = [1, 2, 'a', 'b']
-  // if (!isArray(myArray)) {
-  //   myArray
-  // }
-
-  // const a: Record<string, number> = {}
-
-  // a[myArray[1]] = myArray[0]
-})

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "module": "ES2020",
-    "target": "ES2019",
-    "lib": ["ES2020", "DOM"],
-    "strict": true,
-    "moduleResolution": "node",
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "declaration": true,
-    "declarationDir": "./types/"
-  },
-  "include": ["src/**/*", "test/**/*"]
-}