@nmtjs/core 0.12.5 → 0.12.6

package/dist/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const kOptionalDependency: unique symbol;
+export type kOptionalDependency = typeof kOptionalDependency;
+export declare const kInjectable: unique symbol;
+export type kInjectable = typeof kInjectable;
+export declare const kLazyInjectable: unique symbol;
+export type kLazyInjectable = typeof kLazyInjectable;
+export declare const kValueInjectable: unique symbol;
+export type kValueInjectable = typeof kValueInjectable;
+export declare const kFactoryInjectable: unique symbol;
+export type kFactoryInjectable = typeof kFactoryInjectable;
+export declare const kClassInjectable: unique symbol;
+export type kClassInjectable = typeof kClassInjectable;
+export declare const kProvider: unique symbol;
+export type kProvider = typeof kProvider;
+export declare const kHookCollection: unique symbol;
+export type kHookCollection = typeof kHookCollection;
+export declare const kPlugin: unique symbol;
+export type kPlugin = typeof kPlugin;
+export declare const kMetadata: unique symbol;
+export type kMetadata = typeof kMetadata;

package/dist/constants.js

@@ -1,12 +1,10 @@
-export const kOptionalDependency = Symbol.for("neemata:OptionalDependencyKey");
-export const kInjectable = Symbol.for("neemata:InjectableKey");
-export const kLazyInjectable = Symbol.for("neemata:LazyInjectableKey");
-export const kValueInjectable = Symbol.for("neemata:ValueInjectableKey");
-export const kFactoryInjectable = Symbol.for("neemata:FactoryInjectableKey");
-export const kClassInjectable = Symbol.for("neemata:ClassInjectableKey");
-export const kProvider = Symbol.for("neemata:ProviderKey");
-export const kHookCollection = Symbol.for("neemata:HookCollectionKey");
-export const kPlugin = Symbol.for("neemata:PluginKey");
-export const kMetadata = Symbol.for("neemata:MetadataKey");
-
-//# sourceMappingURL=constants.js.map
+export const kOptionalDependency = Symbol.for('neemata:OptionalDependencyKey');
+export const kInjectable = Symbol.for('neemata:InjectableKey');
+export const kLazyInjectable = Symbol.for('neemata:LazyInjectableKey');
+export const kValueInjectable = Symbol.for('neemata:ValueInjectableKey');
+export const kFactoryInjectable = Symbol.for('neemata:FactoryInjectableKey');
+export const kClassInjectable = Symbol.for('neemata:ClassInjectableKey');
+export const kProvider = Symbol.for('neemata:ProviderKey');
+export const kHookCollection = Symbol.for('neemata:HookCollectionKey');
+export const kPlugin = Symbol.for('neemata:PluginKey');
+export const kMetadata = Symbol.for('neemata:MetadataKey');

package/dist/container.d.ts

@@ -0,0 +1,46 @@
+import { Scope } from './enums.ts';
+import { type AnyInjectable, type Dependencies, type DependencyContext, type ResolveInjectableType } from './injectables.ts';
+import type { Logger } from './logger.ts';
+import type { Registry } from './registry.ts';
+type InstanceWrapper = {
+    private: any;
+    public: any;
+    context: any;
+};
+type ContainerOptions = {
+    registry: Registry;
+    logger: Logger;
+};
+export declare class Container {
+    private readonly application;
+    readonly scope: Exclude<Scope, Scope.Transient>;
+    private readonly parent?;
+    readonly instances: Map<AnyInjectable, InstanceWrapper[]>;
+    private readonly resolvers;
+    private readonly injectables;
+    private readonly dependants;
+    private disposing;
+    constructor(application: ContainerOptions, scope?: Exclude<Scope, Scope.Transient>, parent?: Container | undefined);
+    load(): Promise<void>;
+    fork(scope: Exclude<Scope, Scope.Transient>): Container;
+    dispose(): Promise<void>;
+    containsWithinSelf(injectable: AnyInjectable): boolean;
+    contains(injectable: AnyInjectable): boolean;
+    get<T extends AnyInjectable>(injectable: T): ResolveInjectableType<T>;
+    resolve<T extends AnyInjectable>(injectable: T): Promise<ResolveInjectableType<T>>;
+    createContext<T extends Dependencies>(dependencies: T): Promise<DependencyContext<T>>;
+    private createInjectableContext;
+    provide<T extends AnyInjectable>(injectable: T, instance: ResolveInjectableType<T>): Promise<void>;
+    satisfies(injectable: AnyInjectable): boolean;
+    private findCurrentScopeInjectables;
+    private resolveInjectable;
+    private createResolution;
+    private createInjectFunction;
+    private createDisposeFunction;
+    private getDisposalOrder;
+    private disposeInjectableInstances;
+    private disposeInjectableInstance;
+}
+export type InjectFn = ReturnType<Container['createInjectFunction']>;
+export type DisposeFn = ReturnType<Container['createDisposeFunction']>;
+export {};