feat: add isClass function

benchmarks/typed/isClass.bench.ts

@@ -0,0 +1,11 @@
+import * as _ from 'radashi'
+
+describe('isClass', () => {
+  bench('with class', () => {
+    _.isNumber(class CustomClass {})
+  })
+
+  bench('with non-class', () => {
+    _.isNumber({})
+  })
+})

docs/typed/isClass.mdx

@@ -0,0 +1,31 @@
+---
+title: isClass
+description: Check if a value is a class defined using the `class` syntax.
+---
+
+### Usage
+
+The `isClass` function returns `true` if the provided value is a class defined with the new `class` syntax.
+
+```ts
+import * as _ from 'radashi'
+
+_.isClass(Error) // => true
+class MyClass {}
+_.isClass(MyClass) // => true
+_.isClass(function OldClass() {}) // => false
+_.isClass('abc') // => false
+_.isClass({}) // => false
+_.isClass(undefined) // => false
+```
+
+:::note
+
+Old school classes (defined using constructor functions) will return `false`.
+
+"Native classes", like `Error`, will return `false` because they are not defined using the `class` syntax.
+:::
+
+### Popular use cases
+
+- Type guard would check for a function that must be called with the `new` operator

src/mod.ts

@@ -109,6 +109,7 @@ export * from './string/trim.ts'
 
 export * from './typed/isArray.ts'
 export * from './typed/isBoolean.ts'
+export * from './typed/isClass.ts'
 export * from './typed/isDate.ts'
 export * from './typed/isEmpty.ts'
 export * from './typed/isEqual.ts'

src/typed/isClass.ts

@@ -0,0 +1,18 @@
+import { isFunction, type Class } from 'radashi'
+/**
+ * Checks if the given value is a class. This function verifies
+ * if the value was defined using the `class` syntax. Old school
+ * classes (defined with constructor functions) will return false.
+ * "Native classes" like `Error` will also return false.
+ *
+ * @see https://radashi.js.org/reference/typed/isClass
+ * @example
+ * ```ts
+ * isClass(class CustomClass {}) // => true
+ * isClass('abc') // => false
+ * isClass({}) // => false
+ * ```
+ */
+export function isClass(value: unknown): value is Class {
+  return isFunction(value) && value.toString().startsWith('class ')
+}

src/types.ts

@@ -22,6 +22,11 @@ export declare class Any {
   private any: typeof any
 }
 
+/**
+ * Represents a class constructor.
+ */
+export type Class<T = unknown> = new (...args: any[]) => T
+
 /**
  * Extracts `T` if `T` is not `any`, otherwise `never`.
  *

tests/typed/isClass.test-d.ts

@@ -0,0 +1,18 @@
+import type { Class } from 'radashi'
+import * as _ from 'radashi'
+import { expectTypeOf } from 'vitest'
+
+describe('isClass', () => {
+  test('Type inference', () => {
+    const value = {} as unknown
+    console.log('value is', value)
+    if (_.isClass(value)) {
+      console.log('value is a class')
+      expectTypeOf(value).toMatchTypeOf<Class>()
+      assertType(new value())
+    } else {
+      console.log('value is not a class')
+      expectTypeOf(value).not.toMatchTypeOf<Class>()
+    }
+  })
+})

tests/typed/isClass.test.ts

@@ -0,0 +1,33 @@
+import * as _ from 'radashi'
+
+function OldSchoolClass(something: string) {
+  // @ts-ignore
+  this.something = something
+}
+OldSchoolClass.prototype.doSomething = function () {
+  return `do ${this.something}`
+}
+
+describe('isClass', () => {
+  class Data {}
+  test('returns false for non-Class values', () => {
+    const fn = () => {}
+    expect(_.isClass(OldSchoolClass)).toBeFalsy()
+    expect(_.isClass(fn)).toBeFalsy()
+    expect(_.isClass(undefined)).toBeFalsy()
+    expect(_.isClass(null)).toBeFalsy()
+    expect(_.isClass(false)).toBeFalsy()
+    expect(_.isClass(() => {})).toBeFalsy()
+    expect(_.isClass(async () => {})).toBeFalsy()
+    expect(_.isClass(new Data())).toBeFalsy()
+    expect(_.isClass(Number.NaN)).toBeFalsy()
+    expect(_.isClass([1, 2, 3])).toBeFalsy()
+    expect(_.isClass({})).toBeFalsy()
+    expect(_.isClass('abc')).toBeFalsy()
+    expect(_.isClass(String('abc'))).toBeFalsy()
+  })
+  test('returns true for class values', () => {
+    expect(_.isClass(class CustomError extends Error {})).toBeTruthy()
+    expect(_.isClass(class CustomClass {})).toBeTruthy()
+  })
+})