feat: Make isEmpty a type guard (#16)

src/index.ts

@@ -13,6 +13,7 @@ export * from './utils/has-defined';
 export * from './utils/is-arguments';
 export * from './utils/is-array';
 export * from './utils/is-array-of-strings';
+export * from './utils/is-boolean';
 export * from './utils/is-empty';
 export * from './utils/is-enum-value';
 export * from './utils/is-map-with-values-of-type';
@@ -23,6 +24,7 @@ export * from './utils/is-promise-like';
 export * from './utils/is-set';
 export * from './utils/is-string';
 export * from './utils/is-undefined';
+export * from './utils/is-null';
 
 export * from './utils/chunk';
 export * from './utils/flatten';

src/utils/is-arguments.ts

@@ -6,6 +6,6 @@ import { getTagString } from './get-tag-string';
  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments
  * @returns `true` if `o` is a function's array-like `arguments` variable
  */
-export function isArguments(o: any): boolean {
+export function isArguments(o: unknown): o is IArguments {
    return getTagString(o) === '[object Arguments]';
 }

src/utils/is-array-of-strings.ts

@@ -8,7 +8,7 @@ import { isString } from './is-string';
  * not counted as `string` values, even if the TypeScript compiler's `strictNullChecks`
  * flag is set to `false` in your project.
  */
-export function isArrayOfStrings(values: any): values is string[] {
+export function isArrayOfStrings(values: unknown): values is string[] {
    if (!isArray(values)) {
       return false;
    }

src/utils/is-array.ts

@@ -3,6 +3,6 @@
  *
  * @returns `true` if `o` is an `Array`, regardless of the types that it contains
  */
-export function isArray(o: any): o is unknown[] {
+export function isArray(o: unknown): o is unknown[] {
    return Array.isArray(o);
 }

src/utils/is-boolean.ts

@@ -0,0 +1,3 @@
+export function isBoolean(o: unknown): o is boolean {
+   return o === true || o === false;
+}

src/utils/is-empty.ts

@@ -2,7 +2,32 @@ import { isArray } from './is-array';
 import { isString } from './is-string';
 import { isArguments } from './is-arguments';
 import { isUndefined } from './is-undefined';
+import { isNull } from './is-null';
+import { isBoolean } from './is-boolean';
+import { isNumber } from './is-number';
 import { isSet } from './is-set';
+import { isObject } from './is-object';
+
+
+interface IEmptyArguments extends IArguments {
+   length: 0;
+}
+
+interface IEmptyObj {
+   [s: string]: never;
+}
+
+type IEmptyTypes = (
+   null |
+   undefined |
+   boolean |
+   number |
+   never[] |
+   '' |
+   IEmptyArguments |
+   Set<never> |
+   IEmptyObj
+);
 
 /**
  * Checks if `o` is an empty object. An object is "empty" if it:
@@ -13,8 +38,8 @@ import { isSet } from './is-set';
  *
  * @returns `true` if `o` is empty
  */
-export function isEmpty(o: any): boolean {
-   if (o === null || isUndefined(o)) {
+export function isEmpty(o: unknown): o is IEmptyTypes {
+   if (isNull(o) || isUndefined(o) || isBoolean(o) || isNumber(o)) {
       return true;
    }
    if (isArray(o) || isString(o) || isArguments(o)) {
@@ -23,5 +48,5 @@ export function isEmpty(o: any): boolean {
    if (isSet(o)) {
       return o.size === 0;
    }
-   return Object.keys(o).length === 0;
+   return isObject(o) && Object.keys(o).length === 0;
 }

src/utils/is-enum-value.ts

@@ -1,7 +1,7 @@
 /**
  * Type guard to check to see if the given value is a valid value for the enum.
  */
-export function isEnumValue<T>(enumType: T, value: any): value is T[keyof T] {
+export function isEnumValue<T>(enumType: T, value: unknown): value is T[keyof T] {
    return (Object.keys(enumType) as Array<keyof T>)
       .map((key) => {
          return enumType[key];

src/utils/is-null.ts

@@ -0,0 +1,3 @@
+export function isNull(val: unknown): val is null {
+   return val === null;
+}

src/utils/is-number.ts

@@ -8,6 +8,6 @@ import { isObject } from './is-object';
  * considered `number`s. If you need to check for one of those values, you can use the
  * built-in `Number.isNaN` or `Number.isFinite` functions.
  */
-export function isNumber(o: any): o is number {
+export function isNumber(o: unknown): o is number {
    return typeof o === 'number' || (isObject(o) && getTagString(o) === '[object Number]');
 }

src/utils/is-object.ts

@@ -9,7 +9,7 @@
  * @see https://github.com/jashkenas/underscore/blob/d5fe0fd4060f13b40608cb9d92eda6d857e8752c/underscore.js#L1322
  * @returns `true` if `o` is an `object`
  */
-export function isObject(o: any): o is object {
+export function isObject(o: unknown): o is object {
    let type = typeof o;
 
    return o !== null && (type === 'object' || type === 'function');

src/utils/is-promise-like.ts

@@ -8,6 +8,6 @@ import { isObject } from './is-object';
  *
  * @returns `true` if `o` is `Promise`-like (i.e. has a `then` function)
  */
-export function isPromiseLike(o: any): o is PromiseLike<unknown> {
+export function isPromiseLike(o: unknown): o is PromiseLike<unknown> {
    return isPromise(o) || (isObject(o) && typeof (o as any).then === 'function');
 }

src/utils/is-promise.ts

@@ -6,6 +6,6 @@ import { getTagString } from './get-tag-string';
  *
  * @returns `true` if `o` is a `Promise`
  */
-export function isPromise(o: any): o is Promise<unknown> {
+export function isPromise(o: unknown): o is Promise<unknown> {
    return isObject(o) && getTagString(o) === '[object Promise]';
 }

src/utils/is-string.ts

@@ -8,6 +8,6 @@ import { getTagString } from './get-tag-string';
  * `string` values, even if the TypeScript compiler's `strictNullChecks` flag is set to
  * `false` in your project.
  */
-export function isString(o: any): o is string {
+export function isString(o: unknown): o is string {
    return typeof o === 'string' || (isObject(o) && getTagString(o) === '[object String]');
 }

tests/utils/is-boolean.test.ts

@@ -0,0 +1,16 @@
+import { expect } from 'chai';
+import * as t from '../../src/index';
+
+
+describe('isBoolean', () => {
+
+   it('correctly classifies bools', () => {
+      expect(t.isBoolean(true)).to.strictlyEqual(true);
+      expect(t.isBoolean(false)).to.strictlyEqual(true);
+      expect(t.isBoolean(null)).to.strictlyEqual(false);
+      expect(t.isBoolean(0)).to.strictlyEqual(false);
+      expect(t.isBoolean('')).to.strictlyEqual(false);
+      expect(t.isBoolean({})).to.strictlyEqual(false);
+   });
+
+});

tests/utils/is-null.test.ts

@@ -0,0 +1,23 @@
+import { expect } from 'chai';
+import * as t from '../../src/index';
+
+
+describe('isNull', () => {
+
+   it('correctly classifies null things', () => {
+      let o;
+
+      expect(t.isNull(o)).to.strictlyEqual(false);
+      expect(t.isNull(undefined)).to.strictlyEqual(false);
+      expect(t.isNull(null)).to.strictlyEqual(true);
+
+      let obj: any = { bar: 1, baz: false, bag: undefined, bah: null };
+
+      expect(t.isNull(obj.foo)).to.strictlyEqual(false);
+      expect(t.isNull(obj.bar)).to.strictlyEqual(false);
+      expect(t.isNull(obj.baz)).to.strictlyEqual(false);
+      expect(t.isNull(obj.bag)).to.strictlyEqual(false);
+      expect(t.isNull(obj.bah)).to.strictlyEqual(true);
+   });
+
+});