@venok/core 1.0.0

package/hooks/on-app-bootstrap.hook.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callModuleBootstrapHook = void 0;
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const transient_helper_1 = require("@venok/core/helpers/transient.helper");
+/**
+ * Checks if the given instance has the `onApplicationBootstrap` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnAppBootstrapHook(instance) {
+    return (0, shared_helper_1.isFunction)(instance.onApplicationBootstrap);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances) {
+    return instances
+        .filter((instance) => !(0, shared_helper_1.isNull)(instance))
+        .filter(hasOnAppBootstrapHook)
+        .map(async (instance) => instance.onApplicationBootstrap());
+}
+/**
+ * Calls the `onApplicationBootstrap` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+async function callModuleBootstrapHook(module) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly initialized
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [...providers, ...module.injectables];
+    const nonTransientInstances = (0, transient_helper_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances));
+    const transientInstances = (0, transient_helper_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances));
+    // Call the instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance && hasOnAppBootstrapHook(moduleClassInstance) && moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onApplicationBootstrap();
+    }
+}
+exports.callModuleBootstrapHook = callModuleBootstrapHook;

package/hooks/on-app-shutdown.hook.d.ts

@@ -0,0 +1,9 @@
+import { Module } from "@venok/core/injector/module/module";
+/**
+ * Calls the `onApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal
+ */
+export declare function callAppShutdownHook(module: Module, signal?: string): Promise<any>;

package/hooks/on-app-shutdown.hook.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAppShutdownHook = void 0;
+const transient_helper_1 = require("@venok/core/helpers/transient.helper");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+/**
+ * Checks if the given instance has the `onApplicationShutdown` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnAppShutdownHook(instance) {
+    return (0, shared_helper_1.isFunction)(instance.onApplicationShutdown);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances, signal) {
+    return instances
+        .filter((instance) => !(0, shared_helper_1.isNull)(instance))
+        .filter(hasOnAppShutdownHook)
+        .map(async (instance) => instance.onApplicationShutdown(signal));
+}
+/**
+ * Calls the `onApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal
+ */
+async function callAppShutdownHook(module, signal) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly initialized
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [...providers, ...module.injectables];
+    const nonTransientInstances = (0, transient_helper_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances, signal));
+    const transientInstances = (0, transient_helper_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances, signal));
+    // Call the instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance && hasOnAppShutdownHook(moduleClassInstance) && moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onApplicationShutdown(signal);
+    }
+}
+exports.callAppShutdownHook = callAppShutdownHook;

package/hooks/on-module-destroy.hook.d.ts

@@ -0,0 +1,8 @@
+import { Module } from "@venok/core/injector/module/module";
+/**
+ * Calls the `onModuleDestroy` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+export declare function callModuleDestroyHook(module: Module): Promise<any>;

package/hooks/on-module-destroy.hook.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callModuleDestroyHook = void 0;
+const transient_helper_1 = require("@venok/core/helpers/transient.helper");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+/**
+ * Returns true or false if the given instance has a `onModuleDestroy` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnModuleDestroyHook(instance) {
+    return (0, shared_helper_1.isFunction)(instance.onModuleDestroy);
+}
+/**
+ * Calls the given instances onModuleDestroy hook
+ */
+function callOperator(instances) {
+    return instances
+        .filter((instance) => !(0, shared_helper_1.isNull)(instance))
+        .filter(hasOnModuleDestroyHook)
+        .map(async (instance) => instance.onModuleDestroy());
+}
+/**
+ * Calls the `onModuleDestroy` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+async function callModuleDestroyHook(module) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly destroyed
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [...providers, ...module.injectables];
+    const nonTransientInstances = (0, transient_helper_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances));
+    const transientInstances = (0, transient_helper_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances));
+    // Call the module instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance && hasOnModuleDestroyHook(moduleClassInstance) && moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onModuleDestroy();
+    }
+}
+exports.callModuleDestroyHook = callModuleDestroyHook;

package/hooks/on-module-init.hook.d.ts

@@ -0,0 +1,8 @@
+import { Module } from "@venok/core/injector/module/module";
+/**
+ * Calls the `onModuleInit` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+export declare function callModuleInitHook(module: Module): Promise<void>;

package/hooks/on-module-init.hook.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callModuleInitHook = void 0;
+const transient_helper_1 = require("@venok/core/helpers/transient.helper");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+/**
+ * Returns true or false if the given instance has a `onModuleInit` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnModuleInitHook(instance) {
+    return (0, shared_helper_1.isFunction)(instance.onModuleInit);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances) {
+    return instances
+        .filter((instance) => !(0, shared_helper_1.isNull)(instance))
+        .filter(hasOnModuleInitHook)
+        .map(async (instance) => instance.onModuleInit());
+}
+/**
+ * Calls the `onModuleInit` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+async function callModuleInitHook(module) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly initialized
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [...providers, ...module.injectables];
+    const nonTransientInstances = (0, transient_helper_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances));
+    const transientInstances = (0, transient_helper_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances));
+    // Call the instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance && hasOnModuleInitHook(moduleClassInstance) && moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onModuleInit();
+    }
+}
+exports.callModuleInitHook = callModuleInitHook;

package/index.d.ts

@@ -0,0 +1,10 @@
+import "reflect-metadata";
+export { VenokFactory } from "./application/factory";
+export * from "./application/context";
+export * from "./application/config";
+export * from "./interfaces";
+export * from "./decorators";
+export * from "./injector";
+export * from "./services";
+export { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from "./constants";
+export * from "./metadata-scanner";

package/index.js

@@ -0,0 +1,32 @@
+"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 });
+exports.APP_PIPE = exports.APP_INTERCEPTOR = exports.APP_GUARD = exports.APP_FILTER = exports.VenokFactory = void 0;
+require("reflect-metadata");
+var factory_1 = require("./application/factory");
+Object.defineProperty(exports, "VenokFactory", { enumerable: true, get: function () { return factory_1.VenokFactory; } });
+__exportStar(require("./application/context"), exports);
+__exportStar(require("./application/config"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./injector"), exports);
+__exportStar(require("./services"), exports);
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "APP_FILTER", { enumerable: true, get: function () { return constants_1.APP_FILTER; } });
+Object.defineProperty(exports, "APP_GUARD", { enumerable: true, get: function () { return constants_1.APP_GUARD; } });
+Object.defineProperty(exports, "APP_INTERCEPTOR", { enumerable: true, get: function () { return constants_1.APP_INTERCEPTOR; } });
+Object.defineProperty(exports, "APP_PIPE", { enumerable: true, get: function () { return constants_1.APP_PIPE; } });
+__exportStar(require("./metadata-scanner"), exports);

package/injector/constants.d.ts

@@ -0,0 +1,2 @@
+import { ContextId } from "@venok/core/injector/instance/wrapper";
+export declare const STATIC_CONTEXT: ContextId;

package/injector/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATIC_CONTEXT = void 0;
+const STATIC_CONTEXT_ID = 1;
+exports.STATIC_CONTEXT = Object.freeze({
+    id: STATIC_CONTEXT_ID,
+});

package/injector/container.d.ts

@@ -0,0 +1,61 @@
+import { DynamicModule, Provider } from "@venok/core/interfaces/modules";
+import { Type } from "@venok/core/interfaces";
+import { Module } from "@venok/core/injector/module/module";
+import { TokenFactory } from "@venok/core/injector/module/token-factory";
+import { ModuleCompiler } from "@venok/core/injector/module/compiler";
+import { ModulesContainer } from "@venok/core/injector/module/container";
+import { EnhancerSubtype } from "@venok/core/constants";
+import { ContextId } from "@venok/core/injector/instance/wrapper";
+import { ApplicationConfig } from "@venok/core/application/config";
+import { SerializedGraph } from "@venok/core/inspector/serialized-graph";
+import { Injectable } from "@venok/core/interfaces/injectable.interface";
+type ModuleMetatype = Type<any> | DynamicModule | Promise<DynamicModule>;
+type ModuleScope = Type<any>[];
+export declare class VenokContainer {
+    private readonly _applicationConfig;
+    private readonly globalModules;
+    private readonly moduleTokenFactory;
+    private readonly moduleCompiler;
+    private readonly modules;
+    private readonly dynamicModulesMetadata;
+    private readonly _serializedGraph;
+    private internalCoreModule;
+    constructor(_applicationConfig?: ApplicationConfig | undefined);
+    get serializedGraph(): SerializedGraph;
+    get applicationConfig(): ApplicationConfig | undefined;
+    addModule(metatype: ModuleMetatype | undefined, scope: ModuleScope): Promise<{
+        moduleRef: Module;
+        inserted: boolean;
+    } | undefined>;
+    replaceModule(metatypeToReplace: ModuleMetatype, newMetatype: ModuleMetatype, scope: ModuleScope): Promise<{
+        moduleRef: Module;
+        inserted: boolean;
+    } | undefined>;
+    private setModule;
+    addDynamicMetadata(token: string, dynamicModuleMetadata: Partial<DynamicModule> | undefined, scope: Type<any>[]): Promise<void>;
+    addDynamicModules(modules: any[] | undefined, scope: Type<any>[]): Promise<void>;
+    isGlobalModule(metatype: Type<any>, dynamicMetadata?: Partial<DynamicModule>): boolean;
+    addGlobalModule(module: Module): void;
+    getModules(): ModulesContainer;
+    getModuleCompiler(): ModuleCompiler;
+    getModuleByKey(moduleKey: string): Module;
+    getInternalCoreModuleRef(): Module | undefined;
+    addImport(relatedModule: Type<any> | DynamicModule, token: string): Promise<void>;
+    addProvider(provider: Provider, token: string, enhancerSubtype?: EnhancerSubtype): string | symbol | Function;
+    addInjectable(injectable: Provider, token: string, enhancerSubtype: EnhancerSubtype, host?: Type<Injectable>): string | symbol | Function | import("@venok/core/injector/instance/wrapper").InstanceWrapper<unknown>;
+    addExportedProvider(provider: Type<any>, token: string): void;
+    clear(): void;
+    replace(toReplace: any, options: any & {
+        scope: any[] | null;
+    }): void;
+    bindGlobalScope(): void;
+    bindGlobalsToImports(moduleRef: Module): void;
+    bindGlobalModuleToModule(target: Module, globalModule: Module): void;
+    getDynamicMetadataByToken(token: string): Partial<DynamicModule>;
+    getDynamicMetadataByToken<K extends Exclude<keyof DynamicModule, "global" | "module">>(token: string, metadataKey: K): DynamicModule[K];
+    registerCoreModuleRef(moduleRef: Module): void;
+    getModuleTokenFactory(): TokenFactory;
+    registerRequestProvider<T = any>(request: T, contextId: ContextId): void;
+    private shouldInitOnPreview;
+}
+export {};

package/injector/container.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VenokContainer = void 0;
+const module_1 = require("@venok/core/injector/module/module");
+const token_factory_1 = require("@venok/core/injector/module/token-factory");
+const compiler_1 = require("@venok/core/injector/module/compiler");
+const container_1 = require("@venok/core/injector/module/container");
+const exceptions_1 = require("@venok/core/errors/exceptions");
+const constants_1 = require("@venok/core/constants");
+const initialize_on_preview_allowlist_1 = require("@venok/core/inspector/initialize-on-preview.allowlist");
+const meta_host_collection_1 = require("@venok/core/discovery/meta-host-collection");
+const serialized_graph_1 = require("@venok/core/inspector/serialized-graph");
+const internal_core_module_1 = require("@venok/core/injector/internal-core-module/internal-core-module");
+class VenokContainer {
+    constructor(_applicationConfig = undefined) {
+        this._applicationConfig = _applicationConfig;
+        this.globalModules = new Set();
+        this.moduleTokenFactory = new token_factory_1.TokenFactory();
+        this.moduleCompiler = new compiler_1.ModuleCompiler(this.moduleTokenFactory);
+        this.modules = new container_1.ModulesContainer();
+        this.dynamicModulesMetadata = new Map();
+        this._serializedGraph = new serialized_graph_1.SerializedGraph();
+    }
+    get serializedGraph() {
+        return this._serializedGraph;
+    }
+    get applicationConfig() {
+        return this._applicationConfig;
+    }
+    async addModule(metatype, scope) {
+        // In DependenciesScanner#scanForModules we already check for undefined or invalid modules
+        // We still need to catch the edge-case of `forwardRef(() => undefined)`
+        if (!metatype) {
+            throw new exceptions_1.UndefinedForwardRefException(scope);
+        }
+        const { type, dynamicMetadata, token } = await this.moduleCompiler.compile(metatype);
+        if (this.modules.has(token)) {
+            return {
+                moduleRef: this.modules.get(token),
+                inserted: true,
+            };
+        }
+        return {
+            moduleRef: (await this.setModule({
+                token,
+                type,
+                dynamicMetadata,
+            }, scope)),
+            inserted: true,
+        };
+    }
+    async replaceModule(metatypeToReplace, newMetatype, scope) {
+        // In DependenciesScanner#scanForModules we already check for undefined or invalid modules
+        // We still need to catch the edge-case of `forwardRef(() => undefined)`
+        if (!metatypeToReplace || !newMetatype) {
+            throw new exceptions_1.UndefinedForwardRefException(scope);
+        }
+        const { token } = await this.moduleCompiler.compile(metatypeToReplace);
+        const { type, dynamicMetadata } = await this.moduleCompiler.compile(newMetatype);
+        return {
+            moduleRef: (await this.setModule({
+                token,
+                type,
+                dynamicMetadata,
+            }, scope)),
+            inserted: false,
+        };
+    }
+    async setModule({ token, dynamicMetadata, type }, scope) {
+        const moduleRef = new module_1.Module(type, this);
+        moduleRef.token = token;
+        moduleRef.initOnPreview = this.shouldInitOnPreview(type);
+        this.modules.set(token, moduleRef);
+        // Maybe Error
+        const updatedScope = scope.concat(type);
+        await this.addDynamicMetadata(token, dynamicMetadata, updatedScope);
+        if (this.isGlobalModule(type, dynamicMetadata)) {
+            moduleRef.isGlobal = true;
+            this.addGlobalModule(moduleRef);
+        }
+        return moduleRef;
+    }
+    async addDynamicMetadata(token, dynamicModuleMetadata, scope) {
+        if (!dynamicModuleMetadata) {
+            return;
+        }
+        this.dynamicModulesMetadata.set(token, dynamicModuleMetadata);
+        const { imports } = dynamicModuleMetadata;
+        await this.addDynamicModules(imports, scope);
+    }
+    async addDynamicModules(modules, scope) {
+        if (!modules) {
+            return;
+        }
+        await Promise.all(modules.map((module) => this.addModule(module, scope)));
+    }
+    isGlobalModule(metatype, dynamicMetadata) {
+        if (dynamicMetadata && dynamicMetadata.global) {
+            return true;
+        }
+        return !!Reflect.getMetadata(constants_1.GLOBAL_MODULE_METADATA, metatype);
+    }
+    addGlobalModule(module) {
+        this.globalModules.add(module);
+    }
+    getModules() {
+        return this.modules;
+    }
+    getModuleCompiler() {
+        return this.moduleCompiler;
+    }
+    getModuleByKey(moduleKey) {
+        return this.modules.get(moduleKey);
+    }
+    getInternalCoreModuleRef() {
+        return this.internalCoreModule;
+    }
+    async addImport(relatedModule, token) {
+        if (!this.modules.has(token)) {
+            return;
+        }
+        const moduleRef = this.modules.get(token);
+        const { token: relatedModuleToken } = await this.moduleCompiler.compile(relatedModule);
+        const related = this.modules.get(relatedModuleToken);
+        moduleRef.addImport(related);
+    }
+    addProvider(provider, token, enhancerSubtype) {
+        const moduleRef = this.modules.get(token);
+        if (!provider) {
+            throw new exceptions_1.CircularDependencyException(moduleRef?.metatype.name);
+        }
+        if (!moduleRef) {
+            throw new exceptions_1.UnknownModuleException();
+        }
+        const providerKey = moduleRef.addProvider(provider, enhancerSubtype);
+        const providerRef = moduleRef.getProviderByKey(providerKey);
+        meta_host_collection_1.DiscoverableMetaHostCollection.inspectProvider(this.modules, providerRef);
+        return providerKey;
+    }
+    addInjectable(injectable, token, enhancerSubtype, host) {
+        if (!this.modules.has(token)) {
+            throw new exceptions_1.UnknownModuleException();
+        }
+        const moduleRef = this.modules.get(token);
+        return moduleRef.addInjectable(injectable, enhancerSubtype, host);
+    }
+    addExportedProvider(provider, token) {
+        if (!this.modules.has(token)) {
+            throw new exceptions_1.UnknownModuleException();
+        }
+        const moduleRef = this.modules.get(token);
+        moduleRef.addExportedProvider(provider);
+    }
+    clear() {
+        this.modules.clear();
+    }
+    replace(toReplace, options) {
+        this.modules.forEach((moduleRef) => moduleRef.replace(toReplace, options));
+    }
+    bindGlobalScope() {
+        this.modules.forEach((moduleRef) => this.bindGlobalsToImports(moduleRef));
+    }
+    bindGlobalsToImports(moduleRef) {
+        this.globalModules.forEach((globalModule) => this.bindGlobalModuleToModule(moduleRef, globalModule));
+    }
+    bindGlobalModuleToModule(target, globalModule) {
+        if (target === globalModule || target === this.internalCoreModule) {
+            return;
+        }
+        target.addImport(globalModule);
+    }
+    getDynamicMetadataByToken(token, metadataKey) {
+        const metadata = this.dynamicModulesMetadata.get(token);
+        return metadataKey ? metadata?.[metadataKey] ?? [] : metadata;
+    }
+    registerCoreModuleRef(moduleRef) {
+        this.internalCoreModule = moduleRef;
+        this.modules.set(internal_core_module_1.InternalCoreModule.name, moduleRef);
+    }
+    getModuleTokenFactory() {
+        return this.moduleTokenFactory;
+    }
+    registerRequestProvider(request, contextId) {
+        const wrapper = this.internalCoreModule.getProviderByKey(constants_1.REQUEST);
+        wrapper.setInstanceByContextId(contextId, {
+            instance: request,
+            isResolved: true,
+        });
+    }
+    shouldInitOnPreview(type) {
+        return initialize_on_preview_allowlist_1.InitializeOnPreviewAllowlist.has(type);
+    }
+}
+exports.VenokContainer = VenokContainer;

package/injector/helpers/class-scope.helper.d.ts

@@ -0,0 +1,2 @@
+import { Scope, Type } from "@venok/core/interfaces";
+export declare function getClassScope(provider: Type<unknown>): Scope;

package/injector/helpers/class-scope.helper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClassScope = void 0;
+const constants_1 = require("@venok/core/constants");
+function getClassScope(provider) {
+    const metadata = Reflect.getMetadata(constants_1.SCOPE_OPTIONS_METADATA, provider);
+    return metadata && metadata.scope;
+}
+exports.getClassScope = getClassScope;

package/injector/helpers/classifier.helper.d.ts

@@ -0,0 +1,4 @@
+import { ClassProvider, FactoryProvider, Provider, ValueProvider } from "@venok/core/interfaces/modules";
+export declare function isClassProvider<T = any>(provider: Provider): provider is ClassProvider<T>;
+export declare function isValueProvider<T = any>(provider: Provider): provider is ValueProvider<T>;
+export declare function isFactoryProvider<T = any>(provider: Provider): provider is FactoryProvider<T>;

package/injector/helpers/classifier.helper.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFactoryProvider = exports.isValueProvider = exports.isClassProvider = void 0;
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+function isClassProvider(provider) {
+    return Boolean(provider?.useClass);
+}
+exports.isClassProvider = isClassProvider;
+function isValueProvider(provider) {
+    const providerValue = provider?.useValue;
+    return !(0, shared_helper_1.isUndefined)(providerValue);
+}
+exports.isValueProvider = isValueProvider;
+function isFactoryProvider(provider) {
+    return Boolean(provider.useFactory);
+}
+exports.isFactoryProvider = isFactoryProvider;

package/injector/helpers/is-durable.helper.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "@venok/core/interfaces";
+export declare function isDurable(provider: Type<unknown>): boolean | undefined;

package/injector/helpers/is-durable.helper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDurable = void 0;
+const constants_1 = require("@venok/core/constants");
+function isDurable(provider) {
+    const metadata = Reflect.getMetadata(constants_1.SCOPE_OPTIONS_METADATA, provider);
+    return metadata && metadata.durable;
+}
+exports.isDurable = isDurable;

package/injector/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./container";
+export { ContextId, HostComponentInfo } from "./instance/wrapper";
+export * from "./module/lazy/loader";
+export * from "./module/ref";
+export * from "./module/container";

package/injector/index.js

@@ -0,0 +1,20 @@
+"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("./container"), exports);
+__exportStar(require("./module/lazy/loader"), exports);
+__exportStar(require("./module/ref"), exports);
+__exportStar(require("./module/container"), exports);