@venok/core 1.1.0 → 2.0.0

package/decorators/index.js

@@ -1,31 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./apply.decorator"), exports);
-__exportStar(require("./bind.decorator"), exports);
-__exportStar(require("./catch.decorator"), exports);
-__exportStar(require("./create-param.decorator"), exports);
-__exportStar(require("./dependencies.decorator"), exports);
-__exportStar(require("./exception-filters.decorator"), exports);
-__exportStar(require("./global.decorator"), exports);
-__exportStar(require("./inject.decorator"), exports);
-__exportStar(require("./injectable.decorator"), exports);
-__exportStar(require("./module.decorator"), exports);
-__exportStar(require("./optional.decorator"), exports);
-__exportStar(require("./set-metadata.decorator"), exports);
-__exportStar(require("./use-guards.decorator"), exports);
-__exportStar(require("./use-pipes.decorator"), exports);
-__exportStar(require("./use-interceptors.decorator"), exports);

package/decorators/inject.decorator.d.ts

@@ -1,26 +0,0 @@
-/**
- * Decorator that marks a constructor parameter as a target for
- * Dependency Injection (DI).
- *
- * Any injected provider must be visible within the module scope (loosely
- * speaking, the containing module) of the class it is being injected into. This
- * can be done by:
- *
- * - defining the provider in the same module scope
- * - exporting the provider from one module scope and importing that module into the
- *   module scope of the class being injected into
- * - exporting the provider from a module that is marked as global using the
- *   `@Global()` decorator
- *
- * #### Injection tokens
- * Can be *types* (class names), *strings* or *symbols*. This depends on how the
- * provider with which it is associated was defined. Providers defined with the
- * `@Injectable()` decorator use the class name. Custom Providers may use strings
- * or symbols as the injection token.
- *
- * @param token lookup key for the provider to be injected (assigned to the constructor
- * parameter).
- *
- * @publicApi
- */
-export declare function Inject<T = any>(token?: T): PropertyDecorator & ParameterDecorator;

package/decorators/inject.decorator.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Inject = void 0;
-const shared_helper_1 = require("@venok/core/helpers/shared.helper");
-const constants_1 = require("@venok/core/constants");
-/**
- * Decorator that marks a constructor parameter as a target for
- * Dependency Injection (DI).
- *
- * Any injected provider must be visible within the module scope (loosely
- * speaking, the containing module) of the class it is being injected into. This
- * can be done by:
- *
- * - defining the provider in the same module scope
- * - exporting the provider from one module scope and importing that module into the
- *   module scope of the class being injected into
- * - exporting the provider from a module that is marked as global using the
- *   `@Global()` decorator
- *
- * #### Injection tokens
- * Can be *types* (class names), *strings* or *symbols*. This depends on how the
- * provider with which it is associated was defined. Providers defined with the
- * `@Injectable()` decorator use the class name. Custom Providers may use strings
- * or symbols as the injection token.
- *
- * @param token lookup key for the provider to be injected (assigned to the constructor
- * parameter).
- *
- * @publicApi
- */
-function Inject(token) {
-    return (target, key, index) => {
-        const type = token || Reflect.getMetadata("design:type", target, key);
-        if (!(0, shared_helper_1.isUndefined)(index)) {
-            let dependencies = Reflect.getMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, target) || [];
-            dependencies = [...dependencies, { index, param: type }];
-            Reflect.defineMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, dependencies, target);
-            return;
-        }
-        let properties = Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, target.constructor) || [];
-        properties = [...properties, { key, type }];
-        Reflect.defineMetadata(constants_1.PROPERTY_DEPS_METADATA, properties, target.constructor);
-    };
-}
-exports.Inject = Inject;

package/decorators/injectable.decorator.d.ts

@@ -1,40 +0,0 @@
-import { ScopeOptions, Type } from "@venok/core/interfaces";
-/**
- * Defines the injection scope.
- *
- * @publicApi
- */
-export type InjectableOptions = ScopeOptions;
-/**
- * Decorator that marks a class as a provider(https://venok.com/providers).
- * Providers can be injected into other classes via constructor parameter injection
- * using Venok built-in [Dependency Injection (DI)](https://venok.com/providers#dependency-injection)
- * system.
- *
- * When injecting a provider, it must be visible within the module scope (loosely
- * speaking, the containing module) of the class it is being injected into. This
- * can be done by:
- *
- * - defining the provider in the same module scope
- * - exporting the provider from one module scope and importing that module into the
- *   module scope of the class being injected into
- * - exporting the provider from a module that is marked as global using the
- *   `@Global()` decorator
- *
- * Providers can also be defined in a more explicit and imperative form using
- * various [custom provider](https://venok.com/fundamentals/custom-providers) techniques that expose
- * more capabilities of the DI system.
- *
- * @param options options specifying scope of injectable
- *
- * @see [Providers](https://venok.com/providers)
- * @see [Custom Providers](https://venok.com/fundamentals/custom-providers)
- * @see [Injection Scopes](https://venok.com/fundamentals/injection-scopes)
- *
- * @publicApi
- */
-export declare function Injectable(options?: InjectableOptions): ClassDecorator;
-/**
- * @publicApi
- */
-export declare function mixin<T>(mixinClass: Type<T>): Type<T>;

package/decorators/injectable.decorator.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mixin = exports.Injectable = void 0;
-const uid_1 = require("uid");
-const constants_1 = require("@venok/core/constants");
-/**
- * Decorator that marks a class as a provider(https://venok.com/providers).
- * Providers can be injected into other classes via constructor parameter injection
- * using Venok built-in [Dependency Injection (DI)](https://venok.com/providers#dependency-injection)
- * system.
- *
- * When injecting a provider, it must be visible within the module scope (loosely
- * speaking, the containing module) of the class it is being injected into. This
- * can be done by:
- *
- * - defining the provider in the same module scope
- * - exporting the provider from one module scope and importing that module into the
- *   module scope of the class being injected into
- * - exporting the provider from a module that is marked as global using the
- *   `@Global()` decorator
- *
- * Providers can also be defined in a more explicit and imperative form using
- * various [custom provider](https://venok.com/fundamentals/custom-providers) techniques that expose
- * more capabilities of the DI system.
- *
- * @param options options specifying scope of injectable
- *
- * @see [Providers](https://venok.com/providers)
- * @see [Custom Providers](https://venok.com/fundamentals/custom-providers)
- * @see [Injection Scopes](https://venok.com/fundamentals/injection-scopes)
- *
- * @publicApi
- */
-function Injectable(options) {
-    return (target) => {
-        Reflect.defineMetadata(constants_1.INJECTABLE_WATERMARK, true, target);
-        Reflect.defineMetadata(constants_1.SCOPE_OPTIONS_METADATA, options, target);
-    };
-}
-exports.Injectable = Injectable;
-/**
- * @publicApi
- */
-function mixin(mixinClass) {
-    Object.defineProperty(mixinClass, "name", {
-        value: (0, uid_1.uid)(21),
-    });
-    Injectable()(mixinClass);
-    return mixinClass;
-}
-exports.mixin = mixin;

package/decorators/module.decorator.d.ts

@@ -1,14 +0,0 @@
-import { ModuleMetadata } from "@venok/core/interfaces/modules";
-export declare const INVALID_MODULE_CONFIG_MESSAGE: (text: TemplateStringsArray, property: string) => string;
-/**
- * Decorator that marks a class as a module.
- *
- * Modules are used by Venok to organize the application structure into scopes.
- * Providers are scoped by the module they are declared in. Modules and their
- * classes (Providers) form a graph that determines how Venok
- *
- * @param metadata module configuration metadata
- *
- * @publicApi
- */
-export declare function Module(metadata: ModuleMetadata): ClassDecorator;

package/decorators/module.decorator.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Module = exports.INVALID_MODULE_CONFIG_MESSAGE = void 0;
-const constants_1 = require("../constants");
-const INVALID_MODULE_CONFIG_MESSAGE = (text, property) => `Invalid property '${property}' passed into the @Module() decorator.`;
-exports.INVALID_MODULE_CONFIG_MESSAGE = INVALID_MODULE_CONFIG_MESSAGE;
-const metadataKeys = [constants_1.MODULE_METADATA.IMPORTS, constants_1.MODULE_METADATA.EXPORTS, constants_1.MODULE_METADATA.PROVIDERS];
-function validateModuleKeys(keys) {
-    const validateKey = (key) => {
-        if (metadataKeys.includes(key))
-            return;
-        throw new Error((0, exports.INVALID_MODULE_CONFIG_MESSAGE) `${key}`);
-    };
-    keys.forEach(validateKey);
-}
-/**
- * Decorator that marks a class as a module.
- *
- * Modules are used by Venok to organize the application structure into scopes.
- * Providers are scoped by the module they are declared in. Modules and their
- * classes (Providers) form a graph that determines how Venok
- *
- * @param metadata module configuration metadata
- *
- * @publicApi
- */
-function Module(metadata) {
-    const propsKeys = Object.keys(metadata);
-    validateModuleKeys(propsKeys);
-    return (target) => {
-        for (const property in metadata) {
-            if (metadata.hasOwnProperty(property)) {
-                Reflect.defineMetadata(property, metadata[property], target);
-            }
-        }
-    };
-}
-exports.Module = Module;

package/decorators/optional.decorator.d.ts

@@ -1,14 +0,0 @@
-/**
- * Parameter decorator for an injected dependency marking the
- * dependency as optional.
- *
- * For example:
- * ```typescript
- * constructor(@Optional() @Inject('HTTP_OPTIONS')private readonly httpClient: T) {}
- * ```
- *
- * @see [Optional providers](https://venok.com/providers#optional-providers)
- *
- * @publicApi
- */
-export declare function Optional(): PropertyDecorator & ParameterDecorator;

package/decorators/optional.decorator.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Optional = void 0;
-const constants_1 = require("@venok/core/constants");
-const shared_helper_1 = require("@venok/core/helpers/shared.helper");
-/**
- * Parameter decorator for an injected dependency marking the
- * dependency as optional.
- *
- * For example:
- * ```typescript
- * constructor(@Optional() @Inject('HTTP_OPTIONS')private readonly httpClient: T) {}
- * ```
- *
- * @see [Optional providers](https://venok.com/providers#optional-providers)
- *
- * @publicApi
- */
-function Optional() {
-    return (target, key, index) => {
-        if (!(0, shared_helper_1.isUndefined)(index)) {
-            const args = Reflect.getMetadata(constants_1.OPTIONAL_DEPS_METADATA, target) || [];
-            Reflect.defineMetadata(constants_1.OPTIONAL_DEPS_METADATA, [...args, index], target);
-            return;
-        }
-        const properties = Reflect.getMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, target.constructor) || [];
-        Reflect.defineMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, [...properties, key], target.constructor);
-    };
-}
-exports.Optional = Optional;

package/decorators/set-metadata.decorator.d.ts

@@ -1,18 +0,0 @@
-export type CustomDecorator<TKey = string> = MethodDecorator & ClassDecorator & {
-    KEY: TKey;
-};
-/**
- * Decorator that assigns metadata to the class/function using the
- * specified `key`.
- *
- * Requires two parameters:
- * - `key` - a value defining the key under which the metadata is stored
- * - `value` - metadata to be associated with `key`
- *
- * This metadata can be reflected using the `Reflector` class.
- *
- * Example: `@SetMetadata('roles', ['admin'])`
- *
- * @publicApi
- */
-export declare const SetMetadata: <K = string, V = any>(metadataKey: K, metadataValue: V) => CustomDecorator<K>;

package/decorators/set-metadata.decorator.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetMetadata = void 0;
-/**
- * Decorator that assigns metadata to the class/function using the
- * specified `key`.
- *
- * Requires two parameters:
- * - `key` - a value defining the key under which the metadata is stored
- * - `value` - metadata to be associated with `key`
- *
- * This metadata can be reflected using the `Reflector` class.
- *
- * Example: `@SetMetadata('roles', ['admin'])`
- *
- * @publicApi
- */
-const SetMetadata = (metadataKey, metadataValue) => {
-    const decoratorFactory = (target, key, descriptor) => {
-        if (descriptor) {
-            Reflect.defineMetadata(metadataKey, metadataValue, descriptor.value);
-            return descriptor;
-        }
-        Reflect.defineMetadata(metadataKey, metadataValue, target);
-        return target;
-    };
-    decoratorFactory.KEY = metadataKey;
-    return decoratorFactory;
-};
-exports.SetMetadata = SetMetadata;

package/decorators/use-guards.decorator.d.ts

@@ -1,21 +0,0 @@
-import { CanActivate } from "@venok/core/interfaces/features/guards.interface";
-/**
- * Decorator that binds guards to the scope of the provider or method,
- * depending on its context.
- *
- * When `@UseGuards` is used at the controller level, the guard will be
- * applied to every handler (method) in the provider.
- *
- * When `@UseGuards` is used at the individual handler level, the guard
- * will apply only to that specific method.
- *
- * @param guards a single guard instance or class, or a list of guard instances
- * or classes.
- *
- * @usageNotes
- * Guards can also be set up globally for all controllers and routes
- * using `app.useGlobalGuards()`.
- *
- * @publicApi
- */
-export declare function UseGuards(...guards: (CanActivate | Function)[]): MethodDecorator & ClassDecorator;

package/decorators/use-guards.decorator.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UseGuards = void 0;
-const shared_helper_1 = require("@venok/core/helpers/shared.helper");
-const constants_1 = require("@venok/core/constants");
-const validate_each_helper_1 = require("@venok/core/helpers/validate-each.helper");
-const extends_metadata_helper_1 = require("@venok/core/helpers/extends-metadata.helper");
-/**
- * Decorator that binds guards to the scope of the provider or method,
- * depending on its context.
- *
- * When `@UseGuards` is used at the controller level, the guard will be
- * applied to every handler (method) in the provider.
- *
- * When `@UseGuards` is used at the individual handler level, the guard
- * will apply only to that specific method.
- *
- * @param guards a single guard instance or class, or a list of guard instances
- * or classes.
- *
- * @usageNotes
- * Guards can also be set up globally for all controllers and routes
- * using `app.useGlobalGuards()`.
- *
- * @publicApi
- */
-function UseGuards(...guards) {
-    return (target, key, descriptor) => {
-        const isGuardValid = (guard) => guard && ((0, shared_helper_1.isFunction)(guard) || (0, shared_helper_1.isFunction)(guard.canActivate));
-        if (descriptor) {
-            (0, validate_each_helper_1.validateEach)(target.constructor, guards, isGuardValid, "@UseGuards", "guard");
-            (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.GUARDS_METADATA, guards, descriptor.value);
-            return descriptor;
-        }
-        (0, validate_each_helper_1.validateEach)(target, guards, isGuardValid, "@UseGuards", "guard");
-        (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.GUARDS_METADATA, guards, target);
-        return target;
-    };
-}
-exports.UseGuards = UseGuards;

package/decorators/use-interceptors.decorator.d.ts

@@ -1,21 +0,0 @@
-import { VenokInterceptor } from "@venok/core/interfaces/features/interceptor.interface";
-/**
- * Decorator that binds interceptors to the scope of the provider or method,
- * depending on its context.
- *
- * When `@UseInterceptors` is used at the controller level, the interceptor will
- * be applied to every handler (method) in the provider.
- *
- * When `@UseInterceptors` is used at the individual handler level, the interceptor
- * will apply only to that specific method.
- *
- * @param interceptors a single interceptor instance or class, or a list of
- * interceptor instances or classes.
- *
- * @usageNotes
- * Interceptors can also be set up globally for all controllers and routes
- * using `app.useGlobalInterceptors()`.
- *
- * @publicApi
- */
-export declare function UseInterceptors(...interceptors: (VenokInterceptor | Function)[]): MethodDecorator & ClassDecorator;

package/decorators/use-interceptors.decorator.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UseInterceptors = void 0;
-const shared_helper_1 = require("@venok/core/helpers/shared.helper");
-const constants_1 = require("@venok/core/constants");
-const validate_each_helper_1 = require("@venok/core/helpers/validate-each.helper");
-const extends_metadata_helper_1 = require("@venok/core/helpers/extends-metadata.helper");
-/**
- * Decorator that binds interceptors to the scope of the provider or method,
- * depending on its context.
- *
- * When `@UseInterceptors` is used at the controller level, the interceptor will
- * be applied to every handler (method) in the provider.
- *
- * When `@UseInterceptors` is used at the individual handler level, the interceptor
- * will apply only to that specific method.
- *
- * @param interceptors a single interceptor instance or class, or a list of
- * interceptor instances or classes.
- *
- * @usageNotes
- * Interceptors can also be set up globally for all controllers and routes
- * using `app.useGlobalInterceptors()`.
- *
- * @publicApi
- */
-function UseInterceptors(...interceptors) {
-    return (target, key, descriptor) => {
-        const isInterceptorValid = (interceptor) => interceptor && ((0, shared_helper_1.isFunction)(interceptor) || (0, shared_helper_1.isFunction)(interceptor.intercept));
-        if (descriptor) {
-            (0, validate_each_helper_1.validateEach)(target.constructor, interceptors, isInterceptorValid, "@UseInterceptors", "interceptor");
-            (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.INTERCEPTORS_METADATA, interceptors, descriptor.value);
-            return descriptor;
-        }
-        (0, validate_each_helper_1.validateEach)(target, interceptors, isInterceptorValid, "@UseInterceptors", "interceptor");
-        (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.INTERCEPTORS_METADATA, interceptors, target);
-        return target;
-    };
-}
-exports.UseInterceptors = UseInterceptors;

package/decorators/use-pipes.decorator.d.ts

@@ -1,21 +0,0 @@
-import { PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
-/**
- * Decorator that binds pipes to the scope of the provider or method,
- * depending on its context.
- *
- * When `@UsePipes` is used at the controller level, the pipe will be
- * applied to every handler (method) in the provider.
- *
- * When `@UsePipes` is used at the individual handler level, the pipe
- * will apply only to that specific method.
- *
- * @param pipes a single pipe instance or class, or a list of pipe instances or
- * classes.
- *
- * @usageNotes
- * Pipes can also be set up globally for all controllers and routes
- * using `app.useGlobalPipes()`.
- *
- * @publicApi
- */
-export declare function UsePipes(...pipes: (PipeTransform | Function)[]): ClassDecorator & MethodDecorator;

package/decorators/use-pipes.decorator.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UsePipes = void 0;
-const shared_helper_1 = require("@venok/core/helpers/shared.helper");
-const constants_1 = require("@venok/core/constants");
-const extends_metadata_helper_1 = require("@venok/core/helpers/extends-metadata.helper");
-const validate_each_helper_1 = require("@venok/core/helpers/validate-each.helper");
-/**
- * Decorator that binds pipes to the scope of the provider or method,
- * depending on its context.
- *
- * When `@UsePipes` is used at the controller level, the pipe will be
- * applied to every handler (method) in the provider.
- *
- * When `@UsePipes` is used at the individual handler level, the pipe
- * will apply only to that specific method.
- *
- * @param pipes a single pipe instance or class, or a list of pipe instances or
- * classes.
- *
- * @usageNotes
- * Pipes can also be set up globally for all controllers and routes
- * using `app.useGlobalPipes()`.
- *
- * @publicApi
- */
-function UsePipes(...pipes) {
-    return (target, key, descriptor) => {
-        const isPipeValid = (pipe) => pipe && ((0, shared_helper_1.isFunction)(pipe) || (0, shared_helper_1.isFunction)(pipe.transform));
-        if (descriptor) {
-            (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.PIPES_METADATA, pipes, descriptor.value);
-            return descriptor;
-        }
-        (0, validate_each_helper_1.validateEach)(target, pipes, isPipeValid, "@UsePipes", "pipe");
-        (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.PIPES_METADATA, pipes, target);
-        return target;
-    };
-}
-exports.UsePipes = UsePipes;

package/discovery/meta-host-collection.d.ts

@@ -1,32 +0,0 @@
-import { Type } from "@venok/core/interfaces";
-import { ModulesContainer } from "@venok/core/injector/module/container";
-import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
-export declare class DiscoverableMetaHostCollection {
-    /**
-     * A map of class references to metadata keys.
-     */
-    static readonly metaHostLinks: Map<Function | Type<any>, string>;
-    /**
-     * A map of metadata keys to instance wrappers (providers) with the corresponding metadata key.
-     * The map is weakly referenced by the modules container (unique per application).
-     */
-    private static readonly providersByMetaKey;
-    /**
-     * Adds a link between a class reference and a metadata key.
-     * @param target The class reference.
-     * @param metadataKey The metadata key.
-     */
-    static addClassMetaHostLink(target: Type | Function, metadataKey: string): void;
-    /**
-     * Inspects a provider instance wrapper and adds it to the collection of providers
-     * if it has a metadata key.
-     * @param hostContainerRef A reference to the module's container.
-     * @param instanceWrapper A provider instance wrapper.
-     * @returns void
-     */
-    static inspectProvider(hostContainerRef: ModulesContainer, instanceWrapper: InstanceWrapper): void;
-    static insertByMetaKey(metaKey: string, instanceWrapper: InstanceWrapper, collection: Map<string, Set<InstanceWrapper>>): void;
-    static getProvidersByMetaKey(hostContainerRef: ModulesContainer, metaKey: string): Set<InstanceWrapper>;
-    private static inspectInstanceWrapper;
-    private static getMetaKeyByInstanceWrapper;
-}

package/discovery/meta-host-collection.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscoverableMetaHostCollection = void 0;
-class DiscoverableMetaHostCollection {
-    /**
-     * Adds a link between a class reference and a metadata key.
-     * @param target The class reference.
-     * @param metadataKey The metadata key.
-     */
-    static addClassMetaHostLink(target, metadataKey) {
-        this.metaHostLinks.set(target, metadataKey);
-    }
-    /**
-     * Inspects a provider instance wrapper and adds it to the collection of providers
-     * if it has a metadata key.
-     * @param hostContainerRef A reference to the module's container.
-     * @param instanceWrapper A provider instance wrapper.
-     * @returns void
-     */
-    static inspectProvider(hostContainerRef, instanceWrapper) {
-        return this.inspectInstanceWrapper(hostContainerRef, instanceWrapper, this.providersByMetaKey);
-    }
-    static insertByMetaKey(metaKey, instanceWrapper, collection) {
-        if (collection.has(metaKey)) {
-            const wrappers = collection.get(metaKey);
-            wrappers.add(instanceWrapper);
-        }
-        else {
-            const wrappers = new Set();
-            wrappers.add(instanceWrapper);
-            collection.set(metaKey, wrappers);
-        }
-    }
-    static getProvidersByMetaKey(hostContainerRef, metaKey) {
-        const wrappersByMetaKey = this.providersByMetaKey.get(hostContainerRef);
-        return wrappersByMetaKey.get(metaKey);
-    }
-    static inspectInstanceWrapper(hostContainerRef, instanceWrapper, wrapperByMetaKeyMap) {
-        const metaKey = DiscoverableMetaHostCollection.getMetaKeyByInstanceWrapper(instanceWrapper);
-        if (!metaKey) {
-            return;
-        }
-        let collection;
-        if (wrapperByMetaKeyMap.has(hostContainerRef)) {
-            collection = wrapperByMetaKeyMap.get(hostContainerRef);
-        }
-        else {
-            collection = new Map();
-            wrapperByMetaKeyMap.set(hostContainerRef, collection);
-        }
-        this.insertByMetaKey(metaKey, instanceWrapper, collection);
-    }
-    static getMetaKeyByInstanceWrapper(instanceWrapper) {
-        return this.metaHostLinks.get(
-        // NOTE: Regarding the ternary statement below,
-        // - The condition `!wrapper.metatype` is needed because when we use `useValue`
-        // the value of `wrapper.metatype` will be `null`.
-        // - The condition `wrapper.inject` is needed here because when we use
-        // `useFactory`, the value of `wrapper.metatype` will be the supplied
-        // factory function.
-        // For both cases, we should use `wrapper.instance.constructor` instead
-        // of `wrapper.metatype` to resolve processor's class properly.
-        // But since calling `wrapper.instance` could degrade overall performance
-        // we must defer it as much we can.
-        instanceWrapper.metatype || instanceWrapper.inject
-            ? instanceWrapper.instance?.constructor ?? instanceWrapper.metatype
-            : instanceWrapper.metatype);
-    }
-}
-exports.DiscoverableMetaHostCollection = DiscoverableMetaHostCollection;
-/**
- * A map of class references to metadata keys.
- */
-DiscoverableMetaHostCollection.metaHostLinks = new Map();
-/**
- * A map of metadata keys to instance wrappers (providers) with the corresponding metadata key.
- * The map is weakly referenced by the modules container (unique per application).
- */
-DiscoverableMetaHostCollection.providersByMetaKey = new WeakMap();

package/discovery/module.d.ts

@@ -1,5 +0,0 @@
-/**
- * @publicApi
- */
-export declare class DiscoveryModule {
-}