@tsed/di 8.19.5 → 8.20.0

package/lib/types/common/decorators/controller.d.ts

@@ -1,5 +1,5 @@
 import type { Type } from "@tsed/core/types/Type.js";
-import type { ControllerMiddlewares } from "../domain/ControllerProvider.js";
+import type { ControllerMiddlewares } from "../domain/Provider.js";
 import { ProviderOpts } from "../interfaces/ProviderOpts.js";
 export type PathType = string | RegExp | (string | RegExp)[];
 export interface ControllerOptions extends Partial<ProviderOpts<any>> {

package/lib/types/common/domain/ControllerProvider.d.ts

@@ -1,17 +1,4 @@
-import { TokenProvider } from "../interfaces/TokenProvider.js";
 import { Provider } from "./Provider.js";
-/**
- * Middleware configuration for a controller.
- *
- * Defines middleware tokens to be applied at different stages of request processing.
- *
- * @public
- */
-export interface ControllerMiddlewares {
-    useBefore: TokenProvider[];
-    use: TokenProvider[];
-    useAfter: TokenProvider[];
-}
 /**
  * Specialized provider for HTTP controllers.
  *
@@ -33,18 +20,6 @@ export interface ControllerMiddlewares {
  *
  * @typeParam T - The type of controller class
  * @public
+ * @deprecated Use Provider instead.
  */
-export declare class ControllerProvider<T = any> extends Provider<T> {
-    tokenRouter: string;
-    constructor(token: TokenProvider, options?: Partial<Provider>);
-    /**
-     *
-     * @returns {any[]}
-     */
-    get middlewares(): Partial<ControllerMiddlewares>;
-    /**
-     *
-     * @param middlewares
-     */
-    set middlewares(middlewares: Partial<ControllerMiddlewares>);
-}
+export declare const ControllerProvider: typeof Provider;

package/lib/types/common/domain/Provider.d.ts

@@ -4,6 +4,18 @@ import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
 import type { TokenProvider } from "../interfaces/TokenProvider.js";
 import { ProviderScope } from "./ProviderScope.js";
 import { ProviderType } from "./ProviderType.js";
+/**
+ * Middleware configuration for a controller.
+ *
+ * Defines middleware tokens to be applied at different stages of request processing.
+ *
+ * @public
+ */
+export interface ControllerMiddlewares {
+    useBefore: TokenProvider[];
+    use: TokenProvider[];
+    useAfter: TokenProvider[];
+}
 /**
  * Callback function type for provider lifecycle hooks.
  *
@@ -33,20 +45,65 @@ export type ProviderHookCallback<T = any> = (instance: T, ...args: unknown[]) =>
 export declare class Provider<T = any> implements ProviderOpts<T> {
     #private;
     /**
-     * Token group provider to retrieve all provider from the same type
+     * Global registry for storing all providers in the dependency injection system.
+     * Maps provider tokens to their Provider instances.
+     */
+    static readonly Registry: Map<any, Provider<any>>;
+    /**
+     * Token group provider to retrieve all providers from the same type
      */
     type: ProviderType | TokenProvider;
+    /**
+     * Array of token providers that this provider depends on
+     */
     deps: TokenProvider[];
+    /**
+     * Array of providers or provider arrays to be imported
+     */
     imports: (TokenProvider | [TokenProvider])[];
+    /**
+     * Alternative name/alias for this provider
+     */
     alias: string;
+    /**
+     * Priority value affecting the order of provider initialization
+     */
     priority: number;
+    /**
+     * Optional factory function to create provider instances
+     */
     useFactory?: Function;
+    /**
+     * Optional async factory function to create provider instances
+     */
     useAsyncFactory?: Function;
+    /**
+     * Optional static value to use instead of creating instances
+     */
     useValue?: unknown;
+    /**
+     * Map of lifecycle hook callbacks for this provider
+     */
     hooks: Record<string, ProviderHookCallback<T>>;
+    /**
+     * Router token for routing-related providers
+     */
+    tokenRouter: string;
     [key: string]: any;
+    /**
+     * Creates a new Provider instance
+     * @param token - The token used to identify this provider
+     * @param options - Optional configuration options for the provider
+     */
     constructor(token: TokenProvider<T>, options?: Partial<Provider>);
+    /**
+     * Get the provider's token
+     */
     get token(): TokenProvider;
+    /**
+     * Set the provider's token and initialize stores
+     * @param value - The token to set
+     */
     set token(value: TokenProvider);
     /**
      * @deprecated
@@ -57,10 +114,13 @@ export declare class Provider<T = any> implements ProviderOpts<T> {
      * @param value
      */
     set provide(value: TokenProvider);
+    /**
+     * Gets the class type used to instantiate this provider
+     */
     get useClass(): Type<T>;
     /**
-     * Create a new store if the given value is a class. Otherwise, the value is ignored.
-     * @param value
+     * Sets the class type and initializes store/hooks for this provider
+     * @param value - The class type to use for instantiation
      */
     set useClass(value: Type<T> | AbstractType<T>);
     get className(): string;
@@ -83,10 +143,26 @@ export declare class Provider<T = any> implements ProviderOpts<T> {
      * @param scope
      */
     set scope(scope: ProviderScope);
+    /**
+     * Gets the provider configuration settings
+     */
     get configuration(): Partial<TsED.Configuration>;
+    /**
+     * Sets the provider configuration settings
+     * @param configuration - The configuration object to set
+     */
     set configuration(configuration: Partial<TsED.Configuration>);
     get children(): TokenProvider[];
     set children(children: TokenProvider[]);
+    /**
+     * Gets the configured middleware stack for this provider
+     */
+    get middlewares(): Partial<ControllerMiddlewares>;
+    /**
+     * Sets middleware configuration, merging with existing middlewares
+     * @param middlewares - The middleware configuration to apply
+     */
+    set middlewares(middlewares: Partial<ControllerMiddlewares>);
     getArgOpts(index: number): any;
     /**
      * Retrieves a value from the provider's store.
@@ -104,15 +180,24 @@ export declare class Provider<T = any> implements ProviderOpts<T> {
     isAsync(): boolean;
     clone(): Provider;
     /**
-     *
-     * @returns {boolean}
+     * Checks if this provider has any child controllers
+     * @returns True if provider has children, false otherwise
      */
     hasChildren(): boolean;
     /**
-     *
-     * @returns {boolean}
+     * Checks if this provider has a parent controller
+     * @returns True if provider has a parent, false otherwise
      */
     hasParent(): boolean;
+    /**
+     * Returns a string representation of this provider
+     * @returns A string containing the provider's token, class and factory information
+     */
     toString(): string;
+    /**
+     * Resets the provider's factory configuration
+     * Clears useValue, useFactory and useAsyncFactory
+     * @returns This provider instance
+     */
     reset(): this;
 }

package/lib/types/common/domain/ProviderBuilder.d.ts

@@ -0,0 +1,252 @@
+import type { Store } from "@tsed/core";
+import type { Type } from "@tsed/core/types/Type.js";
+import { Provider } from "../domain/Provider.js";
+import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
+import type { FactoryTokenProvider } from "../interfaces/TokenProvider.js";
+declare global {
+    namespace TsED {
+        interface ProviderBuilder<Token> {
+            /**
+             * Sets the provider scope
+             * @param scope - The scope to set for this provider
+             * @returns Current builder instance
+             */
+            scope(scope: Provider["scope"]): this;
+            /**
+             * Sets the provider path
+             * @param path - The path to set for this provider
+             * @returns Current builder instance
+             */
+            path(path: Provider["path"]): this;
+            /**
+             * Sets the provider alias
+             * @param alias - The alias to set for this provider
+             * @returns Current builder instance
+             */
+            alias(alias: Provider["alias"]): this;
+            /**
+             * Sets the provider hooks
+             * @param hooks - The hooks to set for this provider
+             * @returns Current builder instance
+             */
+            hooks(hooks: Provider["hooks"]): this;
+            /**
+             * Sets the provider dependencies
+             * @param deps - The dependencies to set for this provider
+             * @returns Current builder instance
+             */
+            deps(deps: Provider["deps"]): this;
+            /**
+             * Sets the provider imports
+             * @param imports - The imports to set for this provider
+             * @returns Current builder instance
+             */
+            imports(imports: Provider["imports"]): this;
+            /**
+             * Sets the provider configuration
+             * @param configuration - The configuration to set for this provider
+             * @returns Current builder instance
+             */
+            configuration(configuration: Provider["configuration"]): this;
+            /**
+             * Sets the provider priority
+             * @param priority - The priority to set for this provider
+             * @returns Current builder instance
+             */
+            priority(priority: Provider["priority"]): this;
+            /**
+             * Sets the provider type
+             * @param type - The type to set for this provider
+             * @returns Current builder instance
+             */
+            type(type: Provider["type"]): this;
+            /**
+             * Sets the provider children
+             * @param children - The children to set for this provider
+             * @returns Current builder instance
+             */
+            children(children: Provider["children"]): this;
+            /**
+             * Sets the provider middlewares
+             * @param middlewares - The middlewares to set for this provider
+             * @returns Current builder instance
+             */
+            middlewares(middlewares: Provider["middlewares"]): this;
+            /**
+             * Sets a factory function for the provider
+             * @param factory - Factory function that creates provider instances
+             * @returns Builder instance with updated factory type
+             */
+            factory<FactoryReturn>(factory: (...args: unknown[]) => FactoryReturn): TsED.ProviderBuilder<FactoryTokenProvider<FactoryReturn>>;
+            /**
+             * Sets an async factory function for the provider
+             * @param asyncFactory - Async factory function that creates provider instances
+             * @returns Builder instance with updated factory type
+             */
+            asyncFactory<FactoryReturn>(asyncFactory: (...args: unknown[]) => Promise<FactoryReturn>): TsED.ProviderBuilder<FactoryTokenProvider<FactoryReturn>>;
+            /**
+             * Sets a static value for the provider
+             * @param value - Value to be provided
+             * @returns Builder instance with value type
+             */
+            value<Value>(value: Value): TsED.ProviderBuilder<FactoryTokenProvider<Value>>;
+            /**
+             * Sets the class to be used by the provider
+             * @param k - Class type to be provided
+             * @returns Builder instance with class type
+             */
+            class<TokenKlass extends Type>(k: TokenKlass): TsED.ClassProviderBuilder<TokenKlass>;
+            /**
+             * Gets the provider's store
+             * @returns Provider store instance
+             */
+            store(): Store;
+            /**
+             * Gets the underlying provider instance
+             * @returns Provider instance
+             */
+            inspect(): Provider<Token>;
+            /**
+             * Gets the provider's token
+             * @returns Provider token
+             */
+            token(): Token;
+            /**
+             * Sets a value in the provider's store
+             * @param key - Key to store the value under
+             * @param value - Value to store
+             * @returns Current builder instance
+             */
+            set(key: string, value: unknown): this;
+        }
+        interface ClassProviderBuilder<Token extends Type> extends ProviderBuilder<Token> {
+        }
+    }
+}
+export declare class ProviderBuilder<Token> {
+    protected provider: Provider<Token>;
+    /**
+     * Creates a new Provider Builder instance
+     * @param options - Provider options including token and configuration
+     */
+    constructor(options: ProviderOpts<Token>);
+    static add<Keys extends keyof ClassProviderBuilder, Token extends Type>(property: Keys, method: (this: ClassProviderBuilder<Token>, ...args: Parameters<ClassProviderBuilder<Token>[Keys]>) => ReturnType<ClassProviderBuilder<Token>[Keys]>): typeof ProviderBuilder;
+    /**
+     * Sets the provider scope
+     * @param scope - The scope to set for this provider
+     * @returns Current builder instance
+     */
+    scope(scope: Provider["scope"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider path
+     * @param path - The path to set for this provider
+     * @returns Current builder instance
+     */
+    path(path: Provider["path"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider alias
+     * @param alias - The alias to set for this provider
+     * @returns Current builder instance
+     */
+    alias(alias: Provider["alias"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider hooks
+     * @param hooks - The hooks to set for this provider
+     * @returns Current builder instance
+     */
+    hooks(hooks: Provider["hooks"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider dependencies
+     * @param deps - The dependencies to set for this provider
+     * @returns Current builder instance
+     */
+    deps(deps: Provider["deps"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider imports
+     * @param imports - The imports to set for this provider
+     * @returns Current builder instance
+     */
+    imports(imports: Provider["imports"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider configuration
+     * @param configuration - The configuration to set for this provider
+     * @returns Current builder instance
+     */
+    configuration(configuration: Provider["configuration"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider priority
+     * @param priority - The priority to set for this provider
+     * @returns Current builder instance
+     */
+    priority(priority: Provider["priority"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider type
+     * @param type - The type to set for this provider
+     * @returns Current builder instance
+     */
+    type(type: Provider["type"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider children
+     * @param children - The children to set for this provider
+     * @returns Current builder instance
+     */
+    children(children: Provider["children"]): ProviderBuilder<Token>;
+    /**
+     * Sets the provider middlewares
+     * @param middlewares - The middlewares to set for this provider
+     * @returns Current builder instance
+     */
+    middlewares(middlewares: Provider["middlewares"]): ProviderBuilder<Token>;
+    /**
+     * Sets a factory function for the provider
+     * @param factory - Factory function that creates provider instances
+     * @returns Builder instance with updated factory type
+     */
+    factory<FactoryReturn>(factory: (...args: unknown[]) => FactoryReturn): ProviderBuilder<FactoryTokenProvider<FactoryReturn>>;
+    /**
+     * Sets an async factory function for the provider
+     * @param asyncFactory - Async factory function that creates provider instances
+     * @returns Builder instance with updated factory type
+     */
+    asyncFactory<FactoryReturn>(asyncFactory: (...args: unknown[]) => Promise<FactoryReturn>): ProviderBuilder<FactoryTokenProvider<FactoryReturn>>;
+    /**
+     * Sets a static value for the provider
+     * @param value - Value to be provided
+     * @returns Builder instance with value type
+     */
+    value<Value>(value: Value): ProviderBuilder<FactoryTokenProvider<Value>>;
+    /**
+     * Sets the class to be used by the provider
+     * @param k - Class type to be provided
+     * @returns Builder instance with class type
+     */
+    class<TokenKlass>(k: Type<TokenKlass>): ProviderBuilder<TokenKlass>;
+    /**
+     * Gets the provider's store
+     * @returns Provider store instance
+     */
+    store(): Store;
+    /**
+     * Gets the underlying provider instance
+     * @returns Provider instance
+     */
+    inspect(): Provider<Token>;
+    /**
+     * Gets the provider's token
+     * @returns Provider token
+     */
+    token(): Token;
+    /**
+     * Sets a value in the provider's store
+     * @param key - Key to store the value under
+     * @param value - Value to store
+     * @returns Current builder instance
+     */
+    set(key: string, value: unknown): ProviderBuilder<Token>;
+}
+type ClassProviderBuilder<Token extends Type = any> = TsED.ClassProviderBuilder<Token>;
+export declare function providerBuilder(baseOpts?: Partial<ProviderOpts>): {
+    <Token extends Type>(token: Token, options?: Partial<ProviderOpts>): TsED.ClassProviderBuilder<Token>;
+    <Token extends unknown>(token: Token, options?: Partial<ProviderOpts>): TsED.ProviderBuilder<Token>;
+};
+export {};

package/lib/types/common/extends/intercept.d.ts

@@ -0,0 +1,10 @@
+import { type Type } from "@tsed/core";
+import type { InterceptorMethods } from "../interfaces/InterceptorMethods.js";
+import type { TokenProvider } from "../interfaces/TokenProvider.js";
+declare global {
+    namespace TsED {
+        interface ClassProviderBuilder<Token extends Type> {
+            intercept(property: keyof InstanceType<Token>, interceptor: TokenProvider<InterceptorMethods>, options: Record<string, unknown>): this;
+        }
+    }
+}

package/lib/types/common/fn/injectable.d.ts

@@ -1,6 +1,5 @@
-import { ControllerProvider } from "../domain/ControllerProvider.js";
-import type { Provider } from "../domain/Provider.js";
-type PickedProps = "scope" | "path" | "alias" | "hooks" | "deps" | "imports" | "configuration" | "priority";
+import type { ProviderOpts } from "../interfaces/ProviderOpts.js";
+import type { TokenProvider } from "../interfaces/TokenProvider.js";
 /**
  * Fluent builder for registering providers programmatically.
  *
@@ -25,7 +24,10 @@ type PickedProps = "scope" | "path" | "alias" | "hooks" | "deps" | "imports" | "
  *
  * @public
  */
-export declare const injectable: import("../utils/providerBuilder.js").ProviderBuilderFn<Provider<any>, "type" | PickedProps>;
+export declare const injectable: {
+    <Token extends import("@tsed/core").Type>(token: Token, options?: Partial<ProviderOpts>): TsED.ClassProviderBuilder<Token>;
+    <Token extends unknown>(token: Token, options?: Partial<ProviderOpts>): TsED.ProviderBuilder<Token>;
+};
 /**
  * Fluent builder for registering interceptor providers.
  *
@@ -41,7 +43,10 @@ export declare const injectable: import("../utils/providerBuilder.js").ProviderB
  *
  * @public
  */
-export declare const interceptor: import("../utils/providerBuilder.js").ProviderBuilderFn<Provider<any>, "type" | PickedProps>;
+export declare const interceptor: {
+    <Token extends import("@tsed/core").Type>(token: Token, options?: Partial<ProviderOpts>): TsED.ClassProviderBuilder<Token>;
+    <Token extends unknown>(token: Token, options?: Partial<ProviderOpts>): TsED.ProviderBuilder<Token>;
+};
 /**
  * Fluent builder for registering controller providers.
  *
@@ -60,5 +65,21 @@ export declare const interceptor: import("../utils/providerBuilder.js").Provider
  *
  * @public
  */
-export declare const controller: import("../utils/providerBuilder.js").ProviderBuilderFn<ControllerProvider<any>, "children" | "middlewares" | PickedProps>;
+export declare const controller: {
+    <Token extends import("@tsed/core").Type>(token: Token, options?: Partial<ProviderOpts>): TsED.ClassProviderBuilder<Token>;
+    <Token extends unknown>(token: Token, options?: Partial<ProviderOpts>): TsED.ProviderBuilder<Token>;
+};
+type Opts<Type = any> = Partial<ProviderOpts<Type>> & ({
+    token: TokenProvider<Type>;
+} | {
+    /**
+     * @deprecated use token prop instead
+     */
+    provide: TokenProvider<Type>;
+});
+/**
+ * Register a provider configuration.
+ * @deprecated Since v8. Use injectable() function instead.
+ */
+export declare function registerProvider<Type = any>({ token, provide, ...opts }: Opts<Type>): import("../index.js").Provider<any>;
 export {};

package/lib/types/common/index.d.ts

@@ -25,10 +25,12 @@ export * from "./domain/DIContext.js";
 export * from "./domain/InjectablePropertyType.js";
 export * from "./domain/LocalsContainer.js";
 export * from "./domain/Provider.js";
+export * from "./domain/ProviderBuilder.js";
 export * from "./domain/ProviderScope.js";
 export * from "./domain/ProviderType.js";
 export * from "./errors/InjectionError.js";
 export * from "./errors/InvalidPropertyTokenError.js";
+export * from "./extends/intercept.js";
 export * from "./fn/configuration.js";
 export * from "./fn/constant.js";
 export * from "./fn/inject.js";
@@ -55,7 +57,6 @@ export * from "./interfaces/ResolvedInvokeOptions.js";
 export * from "./interfaces/TokenProvider.js";
 export * from "./interfaces/TokenRoute.js";
 export * from "./registries/GlobalProviders.js";
-export * from "./registries/ProviderRegistry.js";
 export * from "./services/DIConfiguration.js";
 export * from "./services/DILogger.js";
 export * from "./services/InjectorService.js";
@@ -65,7 +66,6 @@ export * from "./utils/createContainer.js";
 export * from "./utils/discoverHooks.js";
 export * from "./utils/getConfiguration.js";
 export * from "./utils/getConstructorDependencies.js";
-export * from "./utils/providerBuilder.js";
 export * from "./utils/setLoggerConfiguration.js";
 export * from "./utils/setLoggerFormat.js";
 export * from "./utils/setLoggerLevel.js";

package/lib/types/common/registries/GlobalProviders.d.ts

@@ -1,52 +1,7 @@
-import type { Type } from "@tsed/core/types/Type.js";
 import { Provider } from "../domain/Provider.js";
-import { ProviderOpts } from "../interfaces/ProviderOpts.js";
-import { RegistrySettings } from "../interfaces/RegistrySettings.js";
-import { TokenProvider } from "../interfaces/TokenProvider.js";
-export declare class GlobalProviderRegistry extends Map<TokenProvider, Provider> {
-    #private;
-    /**
-     * The get() method returns a specified element from a Map object.
-     * @param key Required. The key of the element to return from the Map object.
-     * @returns {T} Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
-     */
-    get(key: TokenProvider): Provider | undefined;
-    /**
-     * The has() method returns a boolean indicating whether an element with the specified key exists or not.
-     * @param key
-     * @returns {boolean}
-     */
-    has(key: TokenProvider): boolean;
-    /**
-     * The set() method adds or updates an element with a specified key and value to a Map object.
-     * @param key Required. The key of the element to add to the Map object.
-     * @param metadata Required. The value of the element to add to the Map object.
-     */
-    set(key: TokenProvider, metadata: Provider): this;
-    /**
-     *
-     * @param target
-     * @param options
-     */
-    merge(target: TokenProvider, options: Partial<ProviderOpts>): Provider<any>;
-    /**
-     * The delete() method removes the specified element from a Map object.
-     * @param key Required. The key of the element to remove from the Map object.
-     * @returns {boolean} Returns true if an element in the Map object existed and has been removed, or false if the element does not exist.
-     */
-    delete(key: TokenProvider): boolean;
-    createRegistry(type: string | symbol, model: Type<Provider>, options?: Partial<RegistrySettings>): this;
-    getRegistrySettings(target: TokenProvider): RegistrySettings;
-    protected createProvider(key: TokenProvider, options: Partial<ProviderOpts<any>>): Provider<any>;
-    /**
-     *
-     * @param key
-     * @param options
-     */
-    protected createIfNotExists(key: TokenProvider, options: Partial<ProviderOpts>): Provider;
-}
 /**
- *
- * @type {GlobalProviders}
+ * Registry for managing global providers in the dependency injection system.
+ * Extends the Map class to store TokenProvider-Provider pairs.
+ * @deprecated Use Provider.Registry instead
  */
-export declare const GlobalProviders: GlobalProviderRegistry;
+export declare const GlobalProviders: Map<any, Provider<any>>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/di",
   "description": "DI module for Ts.ED Framework",
   "type": "module",
-  "version": "8.19.5",
+  "version": "8.20.0",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -29,11 +29,11 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.19.5",
-    "@tsed/core": "8.19.5",
-    "@tsed/hooks": "8.19.5",
+    "@tsed/barrels": "8.20.0",
+    "@tsed/core": "8.20.0",
+    "@tsed/hooks": "8.20.0",
     "@tsed/logger": "^8.0.0",
-    "@tsed/typescript": "8.19.5",
+    "@tsed/typescript": "8.20.0",
     "cross-env": "7.0.3",
     "eslint": "9.12.0",
     "typescript": "5.9.3",

package/lib/esm/common/registries/ProviderRegistry.js

@@ -1,15 +0,0 @@
-import { ControllerProvider } from "../domain/ControllerProvider.js";
-import { ProviderType } from "../domain/ProviderType.js";
-import { injectable } from "../fn/injectable.js";
-import { GlobalProviders } from "./GlobalProviders.js";
-GlobalProviders.createRegistry(ProviderType.CONTROLLER, ControllerProvider);
-/**
- * Register a provider configuration.
- * @deprecated Since v8. Use injectable() function instead.
- */
-export function registerProvider({ token, provide, ...opts }) {
-    return injectable(token || provide, {
-        ...opts,
-        token: token || provide
-    }).inspect();
-}