chore: update isNull and isUndefined and add more predicate utils

docs/reference/predicate/isBoolean.md

@@ -0,0 +1,26 @@
+# isBoolean
+
+The `isBoolean` function checks if a value is a boolean.
+
+## Signature
+
+```typescript
+function isBoolean(val: any): val is boolean
+```
+
+## Parameters
+
+- **`val`**: `unknown` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is boolean, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isBoolean } from 'js-utils-es/predicate';
+
+isBoolean(1); // false
+isBoolean(true); // true
+```

docs/reference/predicate/isDate.md

@@ -0,0 +1,27 @@
+# isDate
+
+The `isDate` function checks if a value is a `Date` object.
+
+## Signature
+
+```typescript
+function isDate(val: any): val is Date
+```
+
+## Parameters
+
+- **`val`**: `unknown` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `Date`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isDate } from 'js-utils-es/predicate';
+
+isDate(1); // false
+isDate(true); // false
+isDate(new Date()); // true
+```

docs/reference/predicate/isFunction.md

@@ -0,0 +1,28 @@
+# isFunction
+
+The `isFunction` function checks if a value is a `Function` object.
+
+## Signature
+
+```typescript
+function isFunction(val: any)
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `Function`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isFunction } from 'js-utils-es/predicate';
+
+isFunction(1); // false
+isFunction(true); // false
+isFunction(new Date()); // false
+isFunction(() => {}); // true
+```

docs/reference/predicate/isNull.md

@@ -10,7 +10,7 @@ This function can also serve as a type predicate in TypeScript, narrowing the ty
 ## Signature
 
 ```typescript
-function isNull(x: unknown): x is null;
+function isNull(val: any): val is null
 ```
 
 ### Parameters

docs/reference/predicate/isNumber.md

@@ -0,0 +1,28 @@
+# isNumber
+
+The `isNumber` function checks if a value is a `number`.
+
+## Signature
+
+```typescript
+function isNumber(val: any): val is number
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `number`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isNumber } from 'js-utils-es/predicate';
+
+isNumber(1); // true
+isNumber(true); // false
+isNumber(new Date()); // false
+isNumber(() => {}); // false
+```

docs/reference/predicate/isObject.md

@@ -0,0 +1,30 @@
+# isObject
+
+The `isObject` function checks if a value is a plain object.
+
+## Signature
+
+```typescript
+function isObject(val: any): val is object
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a plain object, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isObject } from 'js-utils-es/predicate';
+
+isObject({}); // true
+
+isObject(1); // false
+isObject(true); // false
+isObject(new Date()); // false
+isObject(() => {}); // false
+```

docs/reference/predicate/isRegExp.md

@@ -0,0 +1,30 @@
+# isRegExp
+
+The `isRegExp` function checks if a value is a `RegExp`.
+
+## Signature
+
+```typescript
+function isRegExp(val: any): val is RegExp
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `RegExp`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isRegExp } from 'js-utils-es/predicate';
+
+isRegExp(/[az]/g); // true
+
+isRegExp(1); // false
+isRegExp(true); // false
+isRegExp(new Date()); // false
+isRegExp(() => {}); // false
+```

docs/reference/predicate/isString.md

@@ -0,0 +1,30 @@
+# isString
+
+The `isString` function checks if a value is a `string`.
+
+## Signature
+
+```typescript
+function isString(val: unknown): val is string
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `string`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isString } from 'js-utils-es/predicate';
+
+isString('1'); // true
+
+isString(1); // false
+isString(true); // false
+isString(new Date()); // false
+isString(() => {}); // false
+```

docs/reference/predicate/isUndefined.md

@@ -10,12 +10,12 @@ This function can also serve as a type predicate in TypeScript, narrowing the ty
 ## Signature
 
 ```typescript
-function isUndefined(x: unknown): x is undefined;
+function isUndefined(val: any): val is undefined
 ```
 
 ### Parameters
 
-- `x` (`unknown`): The value to test if it is `undefined`.
+- `x` (`any`): The value to test if it is `undefined`.
 
 ### Returns
 

docs/reference/predicate/isWindow.md

@@ -0,0 +1,28 @@
+# isWindow
+
+The `isWindow` function checks if a value is a `window` object.
+
+## Signature
+
+```typescript
+function isWindow(val: any): boolean
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `window` object, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isWindow } from 'js-utils-es/predicate';
+
+isWindow(window); // true
+isWindow(true); // false
+isWindow(new Date()); // false
+isWindow(() => {}); // false
+```

src/predicate/_internal/toString.spec.ts

@@ -0,0 +1,33 @@
+/* eslint-disable prefer-regex-literals */
+import { describe, expect, it } from 'vitest';
+import { toString } from './toString';
+
+describe('toString', () => {
+  it('case1', async () => {
+    expect(toString(1)).toEqual('[object Number]');
+  });
+
+  it('case2', async () => {
+    expect(toString('1')).toEqual('[object String]');
+  });
+
+  it('case3', async () => {
+    expect(toString(true)).toEqual('[object Boolean]');
+  });
+
+  it('case4', async () => {
+    expect(toString([])).toEqual('[object Array]');
+  });
+
+  it('case5', async () => {
+    expect(toString({})).toEqual('[object Object]');
+  });
+
+  it('case6', async () => {
+    expect(toString(new Date())).toEqual('[object Date]');
+  });
+
+  it('case7', async () => {
+    expect(toString(new RegExp(/[a-z]/g))).toEqual('[object RegExp]');
+  });
+});

src/predicate/_internal/toString.ts

@@ -0,0 +1,7 @@
+/**
+ * Convert value to string.
+ * @param {any} v - The value to convert to string.
+ * @returns {string} - return string
+ */
+
+export const toString = (v: any) => Object.prototype.toString.call(v);

src/predicate/isBoolean.spec.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { isBoolean } from './isBoolean';
+
+describe('isBoolean', () => {
+  it('case1', () => {
+    expect(isBoolean(null)).toBe(false);
+    expect(isBoolean(undefined)).toBe(false);
+    expect(isBoolean({})).toBe(false);
+    expect(isBoolean('1')).toBe(false);
+    expect(isBoolean(1)).toBe(false);
+    expect(isBoolean(true)).toBe(true);
+    expect(isBoolean(false)).toBe(true);
+  });
+});

src/predicate/isBoolean.ts

@@ -0,0 +1,3 @@
+export function isBoolean(val: any): val is boolean {
+  return typeof val === 'boolean';
+}

src/predicate/isDate.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { isDate } from './isDate';
+
+describe('isDate', () => {
+  it('case1', () => {
+    expect(isDate(null)).toBe(false);
+    expect(isDate(undefined)).toBe(false);
+    expect(isDate({})).toBe(false);
+    expect(isDate('1')).toBe(false);
+    expect(isDate(1)).toBe(false);
+    expect(isDate(true)).toBe(false);
+    expect(isDate(false)).toBe(false);
+    expect(isDate(new Date())).toBe(true);
+  });
+});

src/predicate/isDate.ts

@@ -0,0 +1,5 @@
+import { toString } from './_internal/toString';
+
+export function isDate(val: any): val is Date {
+  return toString(val) === '[object Date]';
+}

src/predicate/isFunction.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { isFunction } from './isFunction';
+
+describe('isFunction', () => {
+  it('case1', () => {
+    expect(isFunction(null)).toBe(false);
+    expect(isFunction(undefined)).toBe(false);
+    expect(isFunction({})).toBe(false);
+    expect(isFunction('1')).toBe(false);
+    expect(isFunction(1)).toBe(false);
+    expect(isFunction(true)).toBe(false);
+    expect(isFunction(false)).toBe(false);
+    expect(isFunction(new Date())).toBe(false);
+    expect(isFunction(() => {
+      return 2;
+    })).toBe(true);
+  });
+});

src/predicate/isFunction.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line ts/no-unsafe-function-type
+export function isFunction<T extends Function>(val: any): val is T {
+  return typeof val === 'function';
+}

src/predicate/isNull.ts

@@ -1,3 +1,5 @@
+import { toString } from './_internal/toString';
+
 /**
  * Checks if the given value is null.
  *
@@ -18,6 +20,7 @@
  * console.log(isNull(value2)); // false
  * console.log(isNull(value3)); // false
  */
-export function isNull(x: unknown): x is null {
-  return x === null;
+
+export function isNull(val: any): val is null {
+  return toString(val) === '[object Null]';
 }