@codefast/di 0.3.16-canary.0 → 0.3.16-canary.1

package/dist/decorators/inject.mjs

@@ -1,7 +1,7 @@
-import { MissingContainerContextError } from "../errors.mjs";
+import { InternalError, MissingContainerContextError } from "../errors.mjs";
 import { getActiveContainer } from "../environment.mjs";
 import { injectableSlotToResolveOptions } from "../resolve-options.mjs";
-import { INJECT_ACCESSOR_KEY } from "../metadata/metadata-keys.mjs";
+import { INJECT_ACCESSOR_KEY, accessorMetadataByMetadataObjectMap } from "../metadata/metadata-keys.mjs";
 //#region src/decorators/inject.ts
 /**
 * @since 0.3.16-canary.0
@@ -54,9 +54,9 @@ function materializeInjectionDescriptor(dep) {
 	};
 	return base;
 }
-function buildInjectionDescriptor(t, options) {
+function buildInjectionDescriptor(token, options) {
 	const base = {
-		token: t,
+		token,
 		optional: false,
 		multi: false
 	};
@@ -78,15 +78,17 @@ function buildInjectionDescriptor(t, options) {
 /**
 * @since 0.3.16-canary.0
 */
-function inject(t, options) {
-	const descriptor = buildInjectionDescriptor(t, options);
+function inject(token, options) {
+	const descriptor = buildInjectionDescriptor(token, options);
 	const decoratorFn = (_target, context) => {
+		if (context.static === true) throw new InternalError("@inject() on static accessors is not supported; only instance accessors participate in runWithContainer-based property injection.");
 		const meta = context.metadata;
 		if (!Array.isArray(meta[INJECT_ACCESSOR_KEY])) meta[INJECT_ACCESSOR_KEY] = [];
 		meta[INJECT_ACCESSOR_KEY].push({
 			key: context.name,
 			descriptor
 		});
+		accessorMetadataByMetadataObjectMap.set(context.metadata, meta[INJECT_ACCESSOR_KEY]);
 		context.addInitializer(function() {
 			const container = getActiveContainer();
 			if (container === void 0) throw new MissingContainerContextError(String(context.name));
@@ -94,7 +96,7 @@ function inject(t, options) {
 				...options.name !== void 0 ? { name: options.name } : {},
 				...options.tags !== void 0 ? { tags: options.tags } : {}
 			});
-			const value = descriptor.optional ? container.resolveOptional(t, hint) : container.resolve(t, hint);
+			const value = descriptor.optional ? container.resolveOptional(token, hint) : container.resolve(token, hint);
 			context.access.set(this, value);
 		});
 		return {};
@@ -112,9 +114,9 @@ function inject(t, options) {
 /**
 * @since 0.3.16-canary.0
 */
-function optional(t, options) {
+function optional(token, options) {
 	const base = {
-		token: t,
+		token,
 		optional: true,
 		multi: false
 	};
@@ -136,9 +138,9 @@ function optional(t, options) {
 /**
 * @since 0.3.16-canary.0
 */
-function injectAll(t, options) {
+function injectAll(token, options) {
 	const base = {
-		token: t,
+		token,
 		optional: false,
 		multi: true
 	};

package/dist/decorators/injectable.d.mts

@@ -27,6 +27,6 @@ interface InjectableOptions {
 /**
  * @since 0.3.16-canary.0
  */
-declare function injectable(deps?: readonly InjectableDependency[], options?: InjectableOptions): (target: unknown, context: ClassDecoratorContext) => void;
+declare function injectable(deps?: ReadonlyArray<InjectableDependency>, options?: InjectableOptions): (target: unknown, context: ClassDecoratorContext) => void;
 //#endregion
 export { AutoRegisterRegistry, type InjectableDependency, InjectableOptions, createAutoRegisterRegistry, injectable };

package/dist/decorators/injectable.mjs

@@ -1,20 +1,20 @@
-import { INJECTABLE_KEY, constructorMetadataMap } from "../metadata/metadata-keys.mjs";
+import { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, accessorMetadataByConstructorMap, constructorMetadataMap } from "../metadata/metadata-keys.mjs";
 import { normalizeToDescriptor } from "./inject.mjs";
 //#region src/decorators/injectable.ts
 /**
 * @since 0.3.16-canary.0
 */
 function createAutoRegisterRegistry() {
-	const _entries = [];
+	const _registeredEntries = [];
 	return {
 		register(target, scope) {
-			_entries.push({
+			_registeredEntries.push({
 				target,
 				scope
 			});
 		},
 		entries() {
-			return _entries;
+			return _registeredEntries;
 		}
 	};
 }
@@ -23,33 +23,37 @@ function createAutoRegisterRegistry() {
 */
 function injectable(deps, options) {
 	return function(target, context) {
-		const constructorMeta = { params: (deps ?? []).map((dep, index) => {
-			const descriptor = normalizeToDescriptor(dep);
-			const base = {
+		const constructorMetadata = { params: (deps ?? []).map((dependency, index) => {
+			const descriptor = normalizeToDescriptor(dependency);
+			const baseParameterMetadata = {
 				index,
 				token: descriptor.token,
 				optional: descriptor.optional,
 				multi: descriptor.multi
 			};
 			if (descriptor.name !== void 0 && descriptor.tags !== void 0) return {
-				...base,
+				...baseParameterMetadata,
 				name: descriptor.name,
 				tags: descriptor.tags
 			};
 			if (descriptor.name !== void 0) return {
-				...base,
+				...baseParameterMetadata,
 				name: descriptor.name
 			};
 			if (descriptor.tags !== void 0) return {
-				...base,
+				...baseParameterMetadata,
 				tags: descriptor.tags
 			};
-			return base;
+			return baseParameterMetadata;
 		}) };
-		constructorMetadataMap.set(target, constructorMeta);
+		constructorMetadataMap.set(target, constructorMetadata);
 		try {
-			const meta = context.metadata;
-			if (meta !== null && typeof meta === "object") meta[INJECTABLE_KEY] = constructorMeta;
+			const metadata = context.metadata;
+			if (metadata !== null && typeof metadata === "object") {
+				const accessorList = metadata[INJECT_ACCESSOR_KEY];
+				if (Array.isArray(accessorList) && accessorList.length > 0) accessorMetadataByConstructorMap.set(target, accessorList);
+				metadata[INJECTABLE_KEY] = constructorMetadata;
+			}
 		} catch {}
 		if (options?.autoRegister !== void 0) {
 			const scope = options.scope ?? "transient";

package/dist/decorators/lifecycle-decorators.mjs

@@ -1,3 +1,4 @@
+import { InternalError } from "../errors.mjs";
 import { LIFECYCLE_KEY, lifecycleByConstructorMetadataMap, lifecycleMetadataMap } from "../metadata/metadata-keys.mjs";
 //#region src/decorators/lifecycle-decorators.ts
 function appendUniqueMethod(metadata, phase, methodName) {
@@ -25,6 +26,7 @@ function registerByConstructor(target, phase, methodName) {
 */
 function postConstruct() {
 	return function(target, context) {
+		if (context.static === true) throw new InternalError("@postConstruct() applies to instance methods only; static methods are not invoked during instance lifecycle.");
 		const methodName = String(context.name);
 		registerByConstructor(target, "postConstruct", methodName);
 		const existing = lifecycleMetadataMap.get(context.metadata);
@@ -61,6 +63,7 @@ function postConstruct() {
 */
 function preDestroy() {
 	return function(target, context) {
+		if (context.static === true) throw new InternalError("@preDestroy() applies to instance methods only; static methods are not invoked during instance teardown.");
 		const methodName = String(context.name);
 		registerByConstructor(target, "preDestroy", methodName);
 		const existing = lifecycleMetadataMap.get(context.metadata);

package/dist/dependency-graph.d.mts

@@ -25,8 +25,8 @@ interface GraphEdge {
  * @since 0.3.16-canary.0
  */
 interface ContainerGraphJson {
-  readonly nodes: readonly GraphNode[];
-  readonly edges: readonly GraphEdge[];
+  readonly nodes: ReadonlyArray<GraphNode>;
+  readonly edges: ReadonlyArray<GraphEdge>;
   readonly includesParent: boolean;
 }
 /**

package/dist/environment.d.mts

@@ -16,14 +16,14 @@ declare function getActiveContainer(): Container | undefined;
  * @since 0.3.16-canary.0
  */
 interface ResolverCallbacks {
-  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, path: string[], stack: MaterializationFrame[]): Value;
-  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Value;
-  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, path: string[], stack: MaterializationFrame[]): Promise<Value>;
-  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Promise<Value>;
-  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Value | undefined;
-  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Promise<Value | undefined>;
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Value[];
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Promise<Value[]>;
+  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, path: Array<string>, stack: Array<MaterializationFrame>): Value;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Value;
+  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, path: Array<string>, stack: Array<MaterializationFrame>): Promise<Value>;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Value | undefined;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Promise<Value | undefined>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Array<Value>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Promise<Array<Value>>;
 }
 /**
  * @since 0.3.16-canary.0
@@ -33,16 +33,16 @@ declare class DefaultResolutionContext implements ResolutionContext {
   private _resolutionPath;
   private _materializationStack;
   private _currentHint;
-  constructor(resolver: ResolverCallbacks, resolutionPath: string[], materializationStack: MaterializationFrame[], currentHint: ResolveOptions | undefined);
+  constructor(resolver: ResolverCallbacks, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>, currentHint: ResolveOptions | undefined);
   private _graph;
   get graph(): ConstraintContext;
-  reset(resolver: ResolverCallbacks, resolutionPath: string[], materializationStack: MaterializationFrame[], currentHint: ResolveOptions | undefined): void;
+  reset(resolver: ResolverCallbacks, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>, currentHint: ResolveOptions | undefined): void;
   resolve<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value;
   resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value>;
   resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value | undefined;
   resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value | undefined>;
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value[];
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value[]>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Array<Value>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Array<Value>>;
 }
 /**
  * @since 0.3.16-canary.0

package/dist/errors.d.mts

@@ -30,8 +30,8 @@ declare class NoMatchingBindingError extends DiError {
   readonly code = "NO_MATCHING_BINDING";
   readonly tokenName: string;
   readonly hint: ResolveOptions;
-  readonly availableSlots: string[];
-  constructor(tokenName: string, hint: ResolveOptions, availableSlots: string[]);
+  readonly availableSlots: Array<string>;
+  constructor(tokenName: string, hint: ResolveOptions, availableSlots: Array<string>);
 }
 /**
  * @since 0.3.16-canary.0
@@ -39,16 +39,16 @@ declare class NoMatchingBindingError extends DiError {
 declare class AmbiguousBindingError extends DiError {
   readonly code = "AMBIGUOUS_BINDING";
   readonly tokenName: string;
-  readonly candidateIds: readonly BindingIdentifier[];
-  constructor(tokenName: string, candidateIds: readonly BindingIdentifier[]);
+  readonly candidateIds: ReadonlyArray<BindingIdentifier>;
+  constructor(tokenName: string, candidateIds: ReadonlyArray<BindingIdentifier>);
 }
 /**
  * @since 0.3.16-canary.0
  */
 declare class CircularDependencyError extends DiError {
   readonly code = "CIRCULAR_DEPENDENCY";
-  readonly cycle: string[];
-  constructor(cycle: string[]);
+  readonly cycle: Array<string>;
+  constructor(cycle: Array<string>);
 }
 /**
  * @since 0.3.16-canary.0
@@ -75,7 +75,7 @@ interface ScopeViolationDetails {
   readonly consumerScope: BindingScope;
   readonly dependencyToken: string;
   readonly dependencyScope: BindingScope;
-  readonly path: string[];
+  readonly path: Array<string>;
 }
 /**
  * @since 0.3.16-canary.0
@@ -139,5 +139,15 @@ declare class DisposedContainerError extends DiError {
   readonly code = "DISPOSED_CONTAINER";
   constructor();
 }
+/**
+ * @since 0.3.16-canary.0
+ */
+declare class AsyncActivationError extends DiError {
+  readonly code = "ASYNC_ACTIVATION";
+  readonly tokenName: string;
+  readonly hookKind: "postConstruct" | "onActivation";
+  readonly methodName: string | undefined;
+  constructor(tokenName: string, hookKind: "postConstruct" | "onActivation", methodName?: string);
+}
 //#endregion
-export { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };

package/dist/errors.mjs

@@ -177,5 +177,21 @@ var DisposedContainerError = class extends DiError {
 		super("Cannot perform operations on a disposed container.");
 	}
 };
+/**
+* @since 0.3.16-canary.0
+*/
+var AsyncActivationError = class extends DiError {
+	code = "ASYNC_ACTIVATION";
+	tokenName;
+	hookKind;
+	methodName;
+	constructor(tokenName, hookKind, methodName) {
+		const detail = hookKind === "postConstruct" ? `@postConstruct method '${methodName ?? ""}' returned a Promise` : `onActivation for '${tokenName}' returned a Promise`;
+		super(`${detail}. Use resolveAsync() instead.`);
+		this.tokenName = tokenName;
+		this.hookKind = hookKind;
+		this.methodName = methodName;
+	}
+};
 //#endregion
-export { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };

package/dist/graph-adapters/reactflow.d.mts

@@ -30,8 +30,8 @@ interface ReactFlowEdge {
  * @since 0.3.16-canary.0
  */
 interface ReactFlowGraph {
-  nodes: ReactFlowNode[];
-  edges: ReactFlowEdge[];
+  nodes: Array<ReactFlowNode>;
+  edges: Array<ReactFlowEdge>;
 }
 /**
  * @since 0.3.16-canary.0

package/dist/index.d.mts

@@ -4,14 +4,15 @@ import { ActivationHandler, BindingIdentifier, BindingKind, BindingScope, Constr
 import { InjectOptions, InjectableDependency, InjectionDescriptor, inject, injectAll, isInjectionDescriptor, optional } from "./decorators/inject.mjs";
 import { AliasBindingBuilder, BindToBuilder, BindingBuilder, ConstantBindingBuilder, ScopedBindingBuilder, SingletonBindingBuilder, SingletonLifecycleBuilder, TransientBindingBuilder } from "./binding.mjs";
 import { effectiveBindingScope } from "./binding-scope.mjs";
-import { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule } from "./module.mjs";
+import { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll } from "./constraints.mjs";
+import { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule, isSyncModule } from "./module.mjs";
 import { BindingSnapshot, ContainerSnapshot } from "./inspector.mjs";
 import { MetadataReader, MutableLifecycleMetadata } from "./metadata/metadata-types.mjs";
 import { ContainerGraphJson, GraphEdge, GraphNode, GraphOptions } from "./dependency-graph.mjs";
 import { AutoRegisterRegistry, InjectableOptions, createAutoRegisterRegistry, injectable } from "./decorators/injectable.mjs";
 import { Container, ContainerStatic } from "./container.mjs";
 import { postConstruct, preDestroy } from "./decorators/lifecycle-decorators.mjs";
-import { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.mjs";
+import { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.mjs";
 import { injectableSlotToResolveOptions, slotKeyToResolveOptions } from "./resolve-options.mjs";
 import { MetadataReaderToken } from "./metadata/metadata-reader-token.mjs";
-export { type ActivationHandler, type AliasBindingBuilder, AmbiguousBindingError, AsyncDeactivationError, AsyncModule, type AsyncModuleBuilder, AsyncModuleLoadError, AsyncResolutionError, type AutoRegisterRegistry, type BindToBuilder, type BindingBuilder, type BindingIdentifier, type BindingKind, type BindingScope, type BindingSnapshot, CircularDependencyError, type ConstantBindingBuilder, type ConstraintContext, type Constructor, Container, type ContainerGraphJson, type Container as ContainerInterface, type ContainerSnapshot, type ContainerStatic, type DeactivationHandler, type DependencyKey, DiError, DisposedContainerError, type GraphEdge, type GraphNode, type GraphOptions, type InjectOptions, type InjectableDependency, type InjectableOptions, type InjectionDescriptor, InternalError, type MaterializationFrame, type MetadataReader, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, type ModuleBuilder, type MutableLifecycleMetadata, NoMatchingBindingError, RebindUnboundTokenError, type ResolutionContext, type ResolveOptions, type ScopeViolationDetails, ScopeViolationError, type ScopedBindingBuilder, type SingletonBindingBuilder, type SingletonLifecycleBuilder, SyncDisposalNotSupportedError, SyncModule, type Token, TokenNotBoundError, type TokenValue, type TransientBindingBuilder, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectableSlotToResolveOptions, isInjectionDescriptor, isToken, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token, tokenName };
+export { type ActivationHandler, type AliasBindingBuilder, AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModule, type AsyncModuleBuilder, AsyncModuleLoadError, AsyncResolutionError, type AutoRegisterRegistry, type BindToBuilder, type BindingBuilder, type BindingIdentifier, type BindingKind, type BindingScope, type BindingSnapshot, CircularDependencyError, type ConstantBindingBuilder, type ConstraintContext, type Constructor, Container, type ContainerGraphJson, type Container as ContainerInterface, type ContainerSnapshot, type ContainerStatic, type DeactivationHandler, type DependencyKey, DiError, DisposedContainerError, type GraphEdge, type GraphNode, type GraphOptions, type InjectOptions, type InjectableDependency, type InjectableOptions, type InjectionDescriptor, InternalError, type MaterializationFrame, type MetadataReader, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, type ModuleBuilder, type MutableLifecycleMetadata, NoMatchingBindingError, RebindUnboundTokenError, type ResolutionContext, type ResolveOptions, type ScopeViolationDetails, ScopeViolationError, type ScopedBindingBuilder, type SingletonBindingBuilder, type SingletonLifecycleBuilder, SyncDisposalNotSupportedError, SyncModule, type Token, TokenNotBoundError, type TokenValue, type TransientBindingBuilder, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectableSlotToResolveOptions, isInjectionDescriptor, isSyncModule, isToken, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token, tokenName, whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };

package/dist/index.mjs

@@ -1,11 +1,12 @@
 import { effectiveBindingScope } from "./binding-scope.mjs";
-import { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.mjs";
+import { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.mjs";
 import { isToken, token, tokenName } from "./token.mjs";
+import { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll } from "./constraints.mjs";
 import { injectableSlotToResolveOptions, slotKeyToResolveOptions } from "./resolve-options.mjs";
 import { MetadataReaderToken } from "./metadata/metadata-reader-token.mjs";
 import { inject, injectAll, isInjectionDescriptor, optional } from "./decorators/inject.mjs";
-import { AsyncModule, Module, SyncModule } from "./module.mjs";
+import { AsyncModule, Module, SyncModule, isSyncModule } from "./module.mjs";
 import { Container } from "./container.mjs";
 import { createAutoRegisterRegistry, injectable } from "./decorators/injectable.mjs";
 import { postConstruct, preDestroy } from "./decorators/lifecycle-decorators.mjs";
-export { AmbiguousBindingError, AsyncDeactivationError, AsyncModule, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, Container, DiError, DisposedContainerError, InternalError, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, SyncModule, TokenNotBoundError, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectableSlotToResolveOptions, isInjectionDescriptor, isToken, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token, tokenName };
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModule, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, Container, DiError, DisposedContainerError, InternalError, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, SyncModule, TokenNotBoundError, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectableSlotToResolveOptions, isInjectionDescriptor, isSyncModule, isToken, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token, tokenName, whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };

package/dist/inspector.d.mts

@@ -22,8 +22,7 @@ interface BindingSnapshot {
  * @since 0.3.16-canary.0
  */
 interface ContainerSnapshot {
-  readonly ownBindings: readonly BindingSnapshot[];
-  readonly bindings: readonly BindingSnapshot[];
+  readonly ownBindings: ReadonlyArray<BindingSnapshot>;
   readonly cachedSingletonCount: number;
   readonly hasParent: boolean;
   readonly isDisposed: boolean;
@@ -38,7 +37,7 @@ declare class Inspector {
   private readonly _isDisposed;
   constructor(_registry: BindingRegistry, _scope: ScopeManager, _hasParent: boolean, _isDisposed: () => boolean);
   inspect(): ContainerSnapshot;
-  lookupBindings<Value>(token: Token<Value> | Constructor<Value>): readonly BindingSnapshot[];
+  lookupBindings<Value>(token: Token<Value> | Constructor<Value>): ReadonlyArray<BindingSnapshot>;
   has(token: Token<unknown> | Constructor, hint?: ResolveOptions, parentHas?: () => boolean): boolean;
   hasOwn(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
   private allBindingSnapshots;

package/dist/inspector.mjs

@@ -6,6 +6,10 @@ import { tokenName } from "./token.mjs";
 * @since 0.3.16-canary.0
 */
 var Inspector = class {
+	_registry;
+	_scope;
+	_hasParent;
+	_isDisposed;
 	constructor(_registry, _scope, _hasParent, _isDisposed) {
 		this._registry = _registry;
 		this._scope = _scope;
@@ -13,10 +17,8 @@ var Inspector = class {
 		this._isDisposed = _isDisposed;
 	}
 	inspect() {
-		const snapshots = this.allBindingSnapshots();
 		return {
-			ownBindings: snapshots,
-			bindings: snapshots,
+			ownBindings: this.allBindingSnapshots(),
 			cachedSingletonCount: this._scope.getAllSingletons().size,
 			hasParent: this._hasParent,
 			isDisposed: this._isDisposed()

package/dist/lifecycle.d.mts

@@ -12,15 +12,14 @@ declare class LifecycleManager {
   private readonly _activationHooks;
   private readonly _deactivationHooks;
   private _activationVersion;
-  registerActivation<const Value>(t: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void;
-  hasActivationHandlers<const Value>(t: Token<Value> | Constructor<Value>): boolean;
+  registerActivation<const Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void;
+  hasActivationHandlers<const Value>(token: Token<Value> | Constructor<Value>): boolean;
   get activationVersion(): number;
-  registerDeactivation<const Value>(t: Token<Value> | Constructor<Value>, handler: DeactivationHandler<Value>): void;
-  runActivation<const Value>(ctx: ResolutionContext, binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): Promise<Value>;
-  runActivationSync<const Value>(ctx: ResolutionContext, binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): Value;
+  registerDeactivation<const Value>(token: Token<Value> | Constructor<Value>, handler: DeactivationHandler<Value>): void;
+  runActivation<const Value>(resolutionContext: ResolutionContext, binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): Promise<Value>;
+  runActivationSync<const Value>(resolutionContext: ResolutionContext, binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): Value;
   runDeactivation<const Value>(binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): Promise<void>;
   runDeactivationSync<const Value>(binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): void;
-  hasAsyncDeactivation<const Value>(binding: Binding<Value>, instance: Value, _metadataReader: MetadataReader): boolean;
 }
 //#endregion
 export { LifecycleManager };

package/dist/lifecycle.mjs

@@ -1,4 +1,4 @@
-import { AsyncDeactivationError } from "./errors.mjs";
+import { AsyncActivationError, AsyncDeactivationError } from "./errors.mjs";
 import { tokenName } from "./token.mjs";
 //#region src/lifecycle.ts
 /**
@@ -8,128 +8,121 @@ var LifecycleManager = class {
 	_activationHooks = /* @__PURE__ */ new Map();
 	_deactivationHooks = /* @__PURE__ */ new Map();
 	_activationVersion = 0;
-	registerActivation(t, handler) {
+	registerActivation(token, handler) {
 		this._activationVersion += 1;
-		let list = this._activationHooks.get(t);
+		let list = this._activationHooks.get(token);
 		if (list === void 0) {
 			list = [];
-			this._activationHooks.set(t, list);
+			this._activationHooks.set(token, list);
 		}
 		list.push(handler);
 	}
-	hasActivationHandlers(t) {
+	hasActivationHandlers(token) {
 		if (this._activationHooks.size === 0) return false;
-		const list = this._activationHooks.get(t);
+		const list = this._activationHooks.get(token);
 		return list !== void 0 && list.length > 0;
 	}
 	get activationVersion() {
 		return this._activationVersion;
 	}
-	registerDeactivation(t, handler) {
-		let list = this._deactivationHooks.get(t);
+	registerDeactivation(token, handler) {
+		let list = this._deactivationHooks.get(token);
 		if (list === void 0) {
 			list = [];
-			this._deactivationHooks.set(t, list);
+			this._deactivationHooks.set(token, list);
 		}
 		list.push(handler);
 	}
-	async runActivation(ctx, binding, instance, metadataReader) {
-		let result = instance;
+	async runActivation(resolutionContext, binding, instance, metadataReader) {
+		let activatedInstance = instance;
 		if (binding.kind === "class") {
 			const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
 			if (lifecycle?.postConstruct && lifecycle.postConstruct.length > 0) for (const methodName of lifecycle.postConstruct) {
-				const method = result[methodName];
+				const method = activatedInstance[methodName];
 				if (typeof method === "function") {
-					const r = method.call(result);
-					if (r instanceof Promise) await r;
+					const hookResult = method.call(activatedInstance);
+					if (hookResult instanceof Promise) await hookResult;
 				}
 			}
 		}
 		if (binding.kind !== "alias" && binding.onActivation !== void 0) {
-			const activated = binding.onActivation(ctx, result);
-			result = activated instanceof Promise ? await activated : activated;
+			const activationResult = binding.onActivation(resolutionContext, activatedInstance);
+			activatedInstance = activationResult instanceof Promise ? await activationResult : activationResult;
 		}
 		const containerHooks = this._activationHooks.get(binding.token);
 		if (containerHooks !== void 0) for (const hook of containerHooks) {
-			const activated = hook(ctx, result);
-			result = activated instanceof Promise ? await activated : activated;
+			const activationResult = hook(resolutionContext, activatedInstance);
+			activatedInstance = activationResult instanceof Promise ? await activationResult : activationResult;
 		}
-		return result;
+		return activatedInstance;
 	}
-	runActivationSync(ctx, binding, instance, metadataReader) {
-		let result = instance;
+	runActivationSync(resolutionContext, binding, instance, metadataReader) {
+		let activatedInstance = instance;
 		if (binding.kind === "class") {
 			const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
 			if (lifecycle?.postConstruct && lifecycle.postConstruct.length > 0) for (const methodName of lifecycle.postConstruct) {
-				const method = result[methodName];
+				const method = activatedInstance[methodName];
 				if (typeof method === "function") {
-					if (method.call(result) instanceof Promise) throw new Error(`@postConstruct method '${methodName}' returned a Promise. Use resolveAsync() instead.`);
+					if (method.call(activatedInstance) instanceof Promise) throw new AsyncActivationError(tokenName(binding.token), "postConstruct", methodName);
 				}
 			}
 		}
 		if (binding.kind !== "alias" && binding.onActivation !== void 0) {
-			const activated = binding.onActivation(ctx, result);
-			if (activated instanceof Promise) throw new Error(`onActivation for '${tokenName(binding.token)}' returned a Promise. Use resolveAsync() instead.`);
-			result = activated;
+			const activationResult = binding.onActivation(resolutionContext, activatedInstance);
+			if (activationResult instanceof Promise) throw new AsyncActivationError(tokenName(binding.token), "onActivation");
+			activatedInstance = activationResult;
 		}
-		const key = tokenName(binding.token);
+		const tokenDisplayName = tokenName(binding.token);
 		const containerHooks = this._activationHooks.get(binding.token);
 		if (containerHooks !== void 0) for (const hook of containerHooks) {
-			const activated = hook(ctx, result);
-			if (activated instanceof Promise) throw new Error(`Container-level onActivation for '${key}' returned a Promise. Use resolveAsync() instead.`);
-			result = activated;
+			const activationResult = hook(resolutionContext, activatedInstance);
+			if (activationResult instanceof Promise) throw new AsyncActivationError(tokenDisplayName, "onActivation");
+			activatedInstance = activationResult;
 		}
-		return result;
+		return activatedInstance;
 	}
 	async runDeactivation(binding, instance, metadataReader) {
-		const key = binding.token;
-		const containerHooks = this._deactivationHooks.get(key);
+		const tokenKey = binding.token;
+		const containerHooks = this._deactivationHooks.get(tokenKey);
 		if (containerHooks !== void 0) for (const hook of containerHooks) {
-			const r = hook(instance);
-			if (r instanceof Promise) await r;
+			const hookResult = hook(instance);
+			if (hookResult instanceof Promise) await hookResult;
 		}
 		if (binding.kind !== "alias" && binding.onDeactivation !== void 0) {
-			const r = binding.onDeactivation(instance);
-			if (r instanceof Promise) await r;
+			const hookResult = binding.onDeactivation(instance);
+			if (hookResult instanceof Promise) await hookResult;
 		}
 		if (binding.kind === "class") {
 			const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
 			if (lifecycle?.preDestroy && lifecycle.preDestroy.length > 0) for (const methodName of lifecycle.preDestroy) {
 				const method = instance[methodName];
 				if (typeof method === "function") {
-					const r = method.call(instance);
-					if (r instanceof Promise) await r;
+					const hookResult = method.call(instance);
+					if (hookResult instanceof Promise) await hookResult;
 				}
 			}
 		}
 	}
 	runDeactivationSync(binding, instance, metadataReader) {
-		const tName = tokenName(binding.token);
-		const key = binding.token;
-		const containerHooks = this._deactivationHooks.get(key);
+		const tokenDisplayName = tokenName(binding.token);
+		const tokenKey = binding.token;
+		const containerHooks = this._deactivationHooks.get(tokenKey);
 		if (containerHooks !== void 0) {
-			for (const hook of containerHooks) if (hook(instance) instanceof Promise) throw new AsyncDeactivationError(tName);
+			for (const hook of containerHooks) if (hook(instance) instanceof Promise) throw new AsyncDeactivationError(tokenDisplayName);
 		}
 		if (binding.kind !== "alias" && binding.onDeactivation !== void 0) {
-			if (binding.onDeactivation(instance) instanceof Promise) throw new AsyncDeactivationError(tName);
+			if (binding.onDeactivation(instance) instanceof Promise) throw new AsyncDeactivationError(tokenDisplayName);
 		}
 		if (binding.kind === "class") {
 			const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
 			if (lifecycle?.preDestroy && lifecycle.preDestroy.length > 0) for (const methodName of lifecycle.preDestroy) {
 				const method = instance[methodName];
 				if (typeof method === "function") {
-					if (method.call(instance) instanceof Promise) throw new AsyncDeactivationError(tName);
+					if (method.call(instance) instanceof Promise) throw new AsyncDeactivationError(tokenDisplayName);
 				}
 			}
 		}
 	}
-	hasAsyncDeactivation(binding, instance, _metadataReader) {
-		if (binding.kind === "alias") return false;
-		if (binding.onDeactivation !== void 0) {
-			if (binding.onDeactivation(instance) instanceof Promise) return true;
-		}
-		return false;
-	}
 };
 //#endregion
 export { LifecycleManager };