feat(context): relax parameter type for isProviderClass()

This change makes it possible to test if a unknown value is provider class
without casting to Constructor first.

packages/context/src/binding-decorator.ts

@@ -14,7 +14,6 @@ import {
   isProviderClass,
   removeNameAndKeyTags,
 } from './binding-inspector';
-import {Provider} from './provider';
 import {Constructor} from './value-promise';
 
 /**
@@ -97,8 +96,8 @@ export namespace bind {
    */
   export function provider(
     ...specs: BindingSpec[]
-  ): (target: Constructor<Provider<unknown>>) => void {
-    return (target: Constructor<Provider<unknown>>) => {
+  ): (target: Constructor<unknown>) => void {
+    return (target: Constructor<unknown>) => {
       if (!isProviderClass(target)) {
         throw new Error(`Target ${target} is not a Provider`);
       }

packages/context/src/binding-inspector.ts

@@ -57,9 +57,11 @@ export type BindingSpec<T = unknown> = BindingTemplate<T> | BindingScopeAndTags;
  * @typeParam T - Value type
  */
 export function isProviderClass<T>(
-  cls: Constructor<T | Provider<T>>,
+  cls: unknown,
 ): cls is Constructor<Provider<T>> {
-  return typeof cls?.prototype?.value === 'function';
+  return (
+    typeof cls === 'function' && typeof cls.prototype?.value === 'function'
+  );
 }
 
 /**

packages/context/src/interceptor.ts

@@ -396,14 +396,11 @@ export function registerInterceptor(
       : LOCAL_INTERCEPTOR_NAMESPACE;
 
   let binding: Binding<Interceptor>;
-  if (isProviderClass(interceptor as Constructor<Provider<Interceptor>>)) {
-    binding = createBindingFromClass(
-      interceptor as Constructor<Provider<Interceptor>>,
-      {
-        defaultNamespace: namespace,
-        ...options,
-      },
-    );
+  if (isProviderClass(interceptor)) {
+    binding = createBindingFromClass(interceptor, {
+      defaultNamespace: namespace,
+      ...options,
+    });
     if (binding.tagMap[ContextTags.GLOBAL_INTERCEPTOR]) {
       global = true;
     }