feat: add isSymbol & add unit test

__test__/lib/date.test.ts

@@ -118,4 +118,13 @@ describe('formatDateByArray', () => {
     const result = formatDateByArray([2023, 5, 10, 10, 10, 10])
     expect(isValidDate(new Date(result))).toEqual(true)
   })
+
+  it('should handle invalid date generated from array', () => {
+    const invalidDateArray = [2024, NaN, 1];
+    const result = formatDateByArray(invalidDateArray);
+    expect(result).toEqual('Invalid Date');
+    const consoleWarnSpy = jest.spyOn(console, 'warn');
+    expect(consoleWarnSpy).toHaveBeenCalledWith(`Invalid date generated from array: 2024,NaN,1`);
+    consoleWarnSpy.mockRestore();
+  });
 })

__test__/lib/validate.test.ts

@@ -12,8 +12,9 @@ import {
   isNumber,
   isEffectiveNumber,
   isPromise,
-  isEffectiveArray
-} from '../../lib/validate'
+  isValidArray,
+  isValidDate
+} from '../../lib'
 
 describe('isArrayEquals', () => {
   it('should return true if two arrays are equal', () => {
@@ -221,17 +222,56 @@ describe('isPromise', () => {
   })
 })
 
-describe('isEffectiveArray', () => {
+describe('isValidArray', () => {
   test('should return true for a non-empty array', () => {
-    expect(isEffectiveArray([1, 2, 3])).toBe(true)
+    expect(isValidArray([1, 2, 3])).toBe(true)
   })
 
   test('should return false for an empty array', () => {
-    expect(isEffectiveArray([])).toBe(false)
+    expect(isValidArray([])).toBe(false)
   })
 
-  test('should return false for a non-array', () => {
-    // @ts-expect-error: ignore
-    expect(isEffectiveArray(123)).toBe(false)
+  test('should return false for a non-array value', () => {
+    // @ts-ignore
+    expect(isValidArray(123)).toBe(false)
+  })
+
+  test('should return false for an array with length 0', () => {
+    expect(isValidArray([])).toBe(false)
+  })
+
+  test('should return true for an array with length greater than 0', () => {
+    expect(isValidArray([1])).toBe(true)
+  })
+
+  test('should return true for a complex array', () => {
+    expect(isValidArray([{ a: 1 }, { b: 2 }])).toBe(true)
+  })
+
+  test('should return false for undefined', () => {
+    // @ts-ignore
+    expect(isValidArray(undefined)).toBe(false)
+  })
+
+  test('should return false for null', () => {
+    // @ts-ignore
+    expect(isValidArray(null)).toBe(false)
+  })
+
+  test('should return false for an object', () => {
+    // @ts-ignore
+    expect(isValidArray({})).toBe(false)
   })
 })
+
+describe('isValidDate function', () => {
+  it('should return true for a valid date', () => {
+    const validDate = new Date();
+    expect(isValidDate(validDate)).toBe(true);
+  });
+
+  it('should return false for an invalid date', () => {
+    const invalidDate = new Date('invalid');
+    expect(isValidDate(invalidDate)).toBe(false);
+  });
+});

lib/validate.ts

@@ -9,6 +9,17 @@ export const _toString = Object.prototype.toString
 export function isObject(val: unknown): val is object {
   return _toString.call(val) === '[object Object]'
 }
+
+/**
+ * Checks if the given value is an symbol.
+ *
+ * @param {unknown} val - The value to be checked.
+ * @return {boolean} Returns true if the value is an object, otherwise false.
+ */
+
+export function isSymbol(val: unknown): val is Symbol {
+  return typeof val === 'symbol'
+}
 /**
  * Checks if the given value is a function.
  *
@@ -146,10 +157,10 @@ export function isArrayEquals(
  * Checks if the given object has its own property.
  *
  * @param {object} obj - The object to check.
- * @param {string} prop - The property to check.
+ * @param {PropertyKey} prop - The property to check.
  * @return {boolean} Returns true if the object has its own property, otherwise false.
  */
-export function hasOwn(obj: object, prop: string): boolean {
+export function hasOwn(obj: object, prop: PropertyKey): boolean {
   return Object.prototype.hasOwnProperty.call(obj, prop)
 }
 
@@ -159,10 +170,14 @@ export function hasOwn(obj: object, prop: string): boolean {
  * @param {unknown[]} arr - The array to be checked.
  * @returns {boolean} Returns true if the array is valid, false otherwise.
  */
-export function isEffectiveArray(arr: unknown[]): boolean {
+export function isValidArray(arr: unknown[]): boolean {
   return Array.isArray(arr) && arr.length > 0
 }
 
+export function isPropertyKey(val: unknown): val is PropertyKey {
+  return isStr(val) || isNumber(val) || isSymbol(val)
+}
+
 export function isValidDate(date: Date) {
   return date.toString() !== 'Invalid Date'
 }