@lppedd/di-wise-neo 0.15.1 → 0.17.0

package/dist/cjs/index.js

@@ -76,6 +76,25 @@ function untag(message) {
     return message.startsWith("[di-wise-neo]") ? message.substring(13).trimStart() : message;
 }
 
+// @internal
+class HookRegistry {
+    constructor(parent){
+        this.myHooks = new Set(parent?.myHooks);
+    }
+    clear() {
+        this.myHooks.clear();
+    }
+    get() {
+        return this.myHooks;
+    }
+    add(hook) {
+        this.myHooks.add(hook);
+    }
+    delete(hook) {
+        this.myHooks.delete(hook);
+    }
+}
+
 // @internal
 class KeyedStack {
     has(key) {
@@ -144,6 +163,16 @@ function ensureInjectionContext(name) {
     check(context, `${name} can only be invoked within an injection context`);
     return context;
 }
+/**
+ * Asserts that the current stack frame is within an injection context,
+ * meaning it has access to injection functions (`inject`, `optional`, etc.).
+ *
+ * @param fn The function performing the assertion, or a string name used in the error message.
+ * @throws {Error} If the current stack frame is not within an injection context.
+ */ function assertInjectionContext(fn) {
+    const name = typeof fn === "function" ? `${fn.name || "<unnamed>"}()` : fn;
+    ensureInjectionContext(name);
+}
 function createInjectionContext() {
     let current = null;
     function provide(next) {
@@ -160,10 +189,16 @@ function createInjectionContext() {
     ];
 }
 
+function injectAll(token) {
+    const context = ensureInjectionContext("injectAll()");
+    return context.container.resolveAll(token);
+}
+
 function inject(token, name) {
     const context = ensureInjectionContext("inject()");
     return context.container.resolve(token, name);
 }
+
 function injectBy(thisArg, token, name) {
     const context = ensureInjectionContext("injectBy()");
     const resolution = context.resolution;
@@ -181,11 +216,6 @@ function injectBy(thisArg, token, name) {
     }
 }
 
-function injectAll(token) {
-    const context = ensureInjectionContext("injectAll()");
-    return context.container.resolveAll(token);
-}
-
 /**
  * Allows referencing a class declared later in the file by wrapping it
  * in a lazily evaluated function.
@@ -216,15 +246,15 @@ function tokenRef(token) {
 }
 // @internal
 function isClassRef(value) {
-    return value && typeof value === "object" && typeof value.getRefClass === "function";
+    return value != null && typeof value === "object" && typeof value.getRefClass === "function";
 }
 // @internal
 function isTokensRef(value) {
-    return value && typeof value === "object" && typeof value.getRefTokens === "function";
+    return value != null && typeof value === "object" && typeof value.getRefTokens === "function";
 }
 // @internal
 function isTokenRef(value) {
-    return value && typeof value === "object" && typeof value.getRefToken === "function";
+    return value != null && typeof value === "object" && typeof value.getRefToken === "function";
 }
 
 // @internal
@@ -319,10 +349,16 @@ function getMetadata(classOrRef) {
 const classIdentityMap = new WeakMap();
 const metadataMap = new WeakMap();
 
+function optionalAll(token) {
+    const context = ensureInjectionContext("optionalAll()");
+    return context.container.tryResolveAll(token);
+}
+
 function optional(token, name) {
     const context = ensureInjectionContext("optional()");
     return context.container.tryResolve(token, name);
 }
+
 function optionalBy(thisArg, token, name) {
     const context = ensureInjectionContext("optionalBy()");
     const resolution = context.resolution;
@@ -340,11 +376,6 @@ function optionalBy(thisArg, token, name) {
     }
 }
 
-function optionalAll(token) {
-    const context = ensureInjectionContext("optionalAll()");
-    return context.container.tryResolveAll(token);
-}
-
 // @internal
 function isClassProvider(provider) {
     return "useClass" in provider;
@@ -362,41 +393,81 @@ function isExistingProvider(provider) {
     return "useExisting" in provider;
 }
 
-const Scope = {
-    /**
-   * Creates a new value every time the token is resolved.
-   */ Transient: "Transient",
-    /**
-   * Creates and caches a single value per token resolution graph.
-   *
-   * The same value is reused during a single resolution request and is subsequently discarded.
-   */ Resolution: "Resolution",
-    /**
-   * Creates and caches a single value per container.
-   *
-   * If the value is not found in the current container, it is looked up in the parent container,
-   * and so on. It effectively behaves like a _singleton_ scope but allows container-specific overrides.
-   */ Container: "Container"
-};
+// @internal
+function updateParameterMetadata(decorator, target, methodKey, parameterIndex, updateFn) {
+    // Error out immediately if the decorator has been applied to a static method
+    if (methodKey !== undefined && typeof target === "function") {
+        check(false, `@${decorator} cannot be used on static method ${target.name}.${String(methodKey)}`);
+    }
+    if (methodKey === undefined) {
+        // Constructor
+        const metadata = getMetadata(target);
+        const dependency = metadata.getCtorDependency(parameterIndex);
+        updateFn(dependency);
+    } else {
+        // Instance method
+        const metadata = getMetadata(target.constructor);
+        const dependency = metadata.getMethodDependency(methodKey, parameterIndex);
+        updateFn(dependency);
+    }
+}
+// Checks that a constructor or method parameter has only one injection decorator.
+// For example, if both `@Inject` and `@Optional` are used, it becomes difficult to
+// understand which one "wins", unless the user is aware of the decorator evaluation order.
+//
+// @internal
+function checkSingleDecorator(dependency, target, methodKey, parameterIndex) {
+    check(dependency.appliedBy === undefined, ()=>{
+        const param = describeParam(target, methodKey, parameterIndex);
+        return `multiple injection decorators on ${param}, but only one is allowed`;
+    });
+}
+// Checks that the `@Named` decorator is not used in combination with
+// `@InjectAll` or `@OptionalAll`, which ignore the name qualification.
+//
+// @internal
+function checkNamedDecorator(dependency, target, methodKey, parameterIndex) {
+    const { appliedBy, name } = dependency;
+    check(name === undefined || appliedBy !== "InjectAll" && appliedBy !== "OptionalAll", ()=>{
+        const param = describeParam(target, methodKey, parameterIndex);
+        return `@Named has no effect on ${param} when used with @${appliedBy}`;
+    });
+}
+// Returns a human-readable description of the parameter location.
+// For example: "Wizard constructor parameter 2" or "Wizard.set parameter 0"
+//
+// @internal
+function describeParam(target, methodKey, parameterIndex) {
+    const location = methodKey === undefined //
+     ? target.name : `${target.constructor.name}.${String(methodKey)}`;
+    return `${location}(parameter #${parameterIndex})`;
+}
 
 // @__NO_SIDE_EFFECTS__
 function createType(typeName, provider, options) {
     const name = `Type<${typeName}>`;
-    const toString = ()=>name;
-    return provider //
-     ? {
-        name,
-        provider,
-        options,
-        toString
-    } : {
-        name,
-        toString
+    const decorator = (target, propertyKey, parameterIndex)=>{
+        updateParameterMetadata(name, target, propertyKey, parameterIndex, (dependency)=>{
+            checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
+            dependency.appliedBy = "Inject";
+            dependency.tokenRef = tokenRef(()=>decorator);
+        });
     };
+    const type = decorator;
+    Object.defineProperty(type, "name", {
+        value: name
+    });
+    if (provider) {
+        type.provider = provider;
+        type.options = options;
+    }
+    type.__type = undefined;
+    type.toString = ()=>name;
+    return type;
 }
 // @internal
 function isConstructor(token) {
-    return typeof token === "function";
+    return !("__type" in token);
 }
 
 // @internal
@@ -426,7 +497,7 @@ function getTypeName(value) {
 // @internal
 class TokenRegistry {
     constructor(parent){
-        this.myMap = new Map();
+        this.myRegistrations = new Map();
         this.myParent = parent;
     }
     get(token, name) {
@@ -440,9 +511,9 @@ class TokenRegistry {
             internal
         ] || this.getAllFromParent(token, name);
     }
-    set(token, registration) {
+    put(token, registration) {
         check(!internals.has(token), `cannot register reserved token ${token.name}`);
-        let registrations = this.myMap.get(token);
+        let registrations = this.myRegistrations.get(token);
         if (registrations) {
             const name = registration.name;
             if (name !== undefined) {
@@ -450,12 +521,12 @@ class TokenRegistry {
                 check(existing.length === 0, `token ${getTokenName(token)} with name '${name}' is already registered`);
             }
         } else {
-            this.myMap.set(token, registrations = []);
+            this.myRegistrations.set(token, registrations = []);
         }
         registrations.push(registration);
     }
     delete(token, name) {
-        const registrations = this.myMap.get(token);
+        const registrations = this.myRegistrations.get(token);
         if (!registrations) {
             return [];
         }
@@ -466,25 +537,25 @@ class TokenRegistry {
                 (registration.name === name ? removed : updated).push(registration);
             }
             if (removed.length > 0) {
-                this.myMap.set(token, updated);
+                this.myRegistrations.set(token, updated);
                 return removed;
             }
         }
-        this.myMap.delete(token);
+        this.myRegistrations.delete(token);
         return registrations;
     }
     deleteAll() {
-        const tokens = Array.from(this.myMap.keys());
-        const registrations = Array.from(this.myMap.values()).flat();
-        this.myMap.clear();
+        const tokens = Array.from(this.myRegistrations.keys());
+        const registrations = Array.from(this.myRegistrations.values()).flat();
+        this.myRegistrations.clear();
         return [
             tokens,
             registrations
         ];
     }
-    clearRegistrations() {
+    clearCache() {
         const values = new Set();
-        for (const registrations of this.myMap.values()){
+        for (const registrations of this.myRegistrations.values()){
             for(let i = 0; i < registrations.length; i++){
                 const registration = registrations[i];
                 const value = registration.value;
@@ -500,7 +571,7 @@ class TokenRegistry {
         return Array.from(values);
     }
     getAllFromParent(token, name) {
-        let registrations = this.myMap.get(token) || this.myParent?.getAllFromParent(token, name);
+        let registrations = this.myRegistrations.get(token) || this.myParent?.getAllFromParent(token, name);
         if (registrations && name !== undefined) {
             registrations = registrations.filter((r)=>r.name === name);
             check(registrations.length < 2, `internal error: more than one registration named '${name}'`);
@@ -521,7 +592,7 @@ function build(factory, name) {
     internals.set(token, {
         provider: provider,
         options: {
-            scope: Scope.Transient
+            scope: "Transient"
         }
     });
     builders.add(provider);
@@ -533,7 +604,7 @@ const builders = new WeakSet();
 // @internal
 // @internal
 function isDisposable(value) {
-    return value && typeof value === "object" && typeof value.dispose === "function";
+    return value != null && typeof value === "object" && typeof value.dispose === "function";
 }
 
 /**
@@ -544,10 +615,11 @@ function isDisposable(value) {
         this.myDisposed = false;
         this.myParent = parent;
         this.myOptions = {
-            autoRegister: options?.autoRegister ?? false,
-            defaultScope: options?.defaultScope ?? Scope.Transient
+            defaultScope: options?.defaultScope ?? "Transient",
+            autoRegister: options?.autoRegister ?? false
         };
-        this.myTokenRegistry = new TokenRegistry(this.myParent?.myTokenRegistry);
+        this.myHookRegistry = new HookRegistry(parent?.myHookRegistry);
+        this.myTokenRegistry = new TokenRegistry(parent?.myTokenRegistry);
     }
     get registry() {
         return this.myTokenRegistry;
@@ -566,15 +638,15 @@ function isDisposable(value) {
     createChild(options) {
         this.checkDisposed();
         const container = new ContainerImpl(this, {
-            autoRegister: options?.autoRegister ?? this.myOptions.autoRegister,
-            defaultScope: options?.defaultScope ?? this.myOptions.defaultScope
+            defaultScope: options?.defaultScope ?? this.myOptions.defaultScope,
+            autoRegister: options?.autoRegister ?? this.myOptions.autoRegister
         });
         this.myChildren.add(container);
         return container;
     }
     clearCache() {
         this.checkDisposed();
-        return this.myTokenRegistry.clearRegistrations();
+        return this.myTokenRegistry.clearCache();
     }
     getCached(token) {
         this.checkDisposed();
@@ -651,6 +723,12 @@ function isDisposable(value) {
         this.checkDisposed();
         return this.resolveAllToken(token, true);
     }
+    addHook(hook) {
+        this.myHookRegistry.add(hook);
+    }
+    removeHook(hook) {
+        this.myHookRegistry.delete(hook);
+    }
     dispose() {
         if (this.myDisposed) {
             return;
@@ -659,22 +737,23 @@ function isDisposable(value) {
         for (const child of this.myChildren){
             child.dispose();
         }
+        this.myDisposed = true;
         this.myChildren.clear();
-        // Remove ourselves from our parent container
         this.myParent?.myChildren?.delete(this);
-        this.myDisposed = true;
         const [, registrations] = this.myTokenRegistry.deleteAll();
-        const disposedRefs = new Set();
-        // Dispose all resolved (aka instantiated) tokens that implement the Disposable interface
+        const values = new Set();
         for (const registration of registrations){
-            const value = registration.value?.current;
-            if (isDisposable(value) && !disposedRefs.has(value)) {
-                disposedRefs.add(value);
-                value.dispose();
+            // Only container-scoped registrations use 'registration.value'
+            if (registration.value) {
+                const value = registration.value.current;
+                // Dispose all cached values that implement the Disposable interface
+                if (!values.has(value) && values.add(value) && isDisposable(value)) {
+                    value.dispose();
+                }
             }
         }
-        // Allow values to be GCed
-        disposedRefs.clear();
+        this.notifyDisposeHooks(Array.from(values));
+        this.myHookRegistry.clear();
     }
     registerClass(Class) {
         const metadata = getMetadata(Class);
@@ -689,11 +768,11 @@ function isDisposable(value) {
             dependencies: metadata.dependencies
         };
         // Register the class itself
-        this.myTokenRegistry.set(Class, registration);
+        this.myTokenRegistry.put(Class, registration);
         // Register the additional tokens specified via class decorators.
         // These tokens will point to the original Class token and will have the same scope.
         for (const token of metadata.tokensRef.getRefTokens()){
-            this.myTokenRegistry.set(token, {
+            this.myTokenRegistry.put(token, {
                 name: name,
                 provider: {
                     useExisting: [
@@ -703,8 +782,10 @@ function isDisposable(value) {
                 }
             });
         }
-        // Eager-instantiate only if the class is container-scoped
-        if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
+        // Eager-instantiate only if the class is container-scoped.
+        // Note that we are comparing the scope using the registration configured just above,
+        // which takes into account both the metadata and the container option as a fallback.
+        if (metadata.eagerInstantiate && registration.options?.scope === "Container") {
             this.resolveProviderValue(Class, registration);
         }
     }
@@ -724,9 +805,11 @@ function isDisposable(value) {
                 },
                 dependencies: metadata.dependencies
             };
-            this.myTokenRegistry.set(token, registration);
-            // Eager-instantiate only if the provided class is container-scoped
-            if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
+            this.myTokenRegistry.put(token, registration);
+            // Eager-instantiate only if the provided class is container-scoped.
+            // Note that we are comparing the scope using the registration configured just above,
+            // which takes into account both the metadata and the container option as a fallback.
+            if (metadata.eagerInstantiate && registration.options?.scope === "Container") {
                 this.resolveProviderValue(token, registration);
             }
         } else {
@@ -734,7 +817,7 @@ function isDisposable(value) {
                 const [targetToken] = this.getTargetToken(provider);
                 check(token !== targetToken, `token ${getTokenName(token)} cannot alias itself via useExisting`);
             }
-            this.myTokenRegistry.set(token, {
+            this.myTokenRegistry.put(token, {
                 name: name,
                 provider: provider,
                 options: options
@@ -839,7 +922,7 @@ function isDisposable(value) {
         }
         if (isFactoryProvider(provider)) {
             const factory = provider.useFactory;
-            return this.resolveScopedValue(token, registration, factory);
+            return this.resolveScopedValue(token, registration, ()=>factory());
         }
         if (isValueProvider(provider)) {
             return provider.useValue;
@@ -877,7 +960,7 @@ function isDisposable(value) {
         ];
         try {
             switch(scope){
-                case Scope.Container:
+                case "Container":
                     {
                         const valueRef = registration.value;
                         if (valueRef) {
@@ -888,9 +971,10 @@ function isDisposable(value) {
                         registration.value = {
                             current: value
                         };
+                        this.notifyProvideHooks(value, scope);
                         return value;
                     }
-                case Scope.Resolution:
+                case "Resolution":
                     {
                         const valueRef = resolution.values.get(provider);
                         if (valueRef) {
@@ -901,12 +985,15 @@ function isDisposable(value) {
                         resolution.values.set(provider, {
                             current: value
                         });
+                        this.notifyProvideHooks(value, scope);
                         return value;
                     }
-                case Scope.Transient:
+                case "Transient":
                     {
                         const args = this.resolveCtorDependencies(registration);
-                        return this.injectMethodDependencies(registration, factory(args));
+                        const value = this.injectMethodDependencies(registration, factory(args));
+                        this.notifyProvideHooks(value, scope);
+                        return value;
                     }
             }
         } finally{
@@ -932,7 +1019,6 @@ function isDisposable(value) {
         }
         return [];
     }
-    // Call context: decorator-based injection
     injectMethodDependencies(registration, instance) {
         const dependencies = registration.dependencies;
         if (dependencies) {
@@ -985,6 +1071,16 @@ function isDisposable(value) {
                 return instance ? optionalAll(token) : this.tryResolveAll(token);
         }
     }
+    notifyProvideHooks(value, scope) {
+        for (const hook of this.myHookRegistry.get()){
+            hook.onProvide?.(value, scope);
+        }
+    }
+    notifyDisposeHooks(values) {
+        for (const hook of this.myHookRegistry.get()){
+            hook.onDispose?.(values);
+        }
+    }
     checkDisposed() {
         check(!this.myDisposed, "container is disposed");
     }
@@ -1040,68 +1136,19 @@ function isDisposable(value) {
         const ctor = Class;
         const metadata = getMetadata(ctor);
         const currentScope = metadata.scope;
-        check(!currentScope || currentScope.value === Scope.Container, ()=>{
+        check(!currentScope || currentScope.value === "Container", ()=>{
             const { value, appliedBy } = currentScope;
             const className = getTokenName(ctor);
-            return `class ${className}: Scope.${value} was already set by @${appliedBy},\n  ` + `but @EagerInstantiate is trying to set a conflicting Scope.Container.\n  ` + `Only one decorator should set the class scope, or all must agree on the same value.`;
+            return `class ${className}: scope ${value} was already set by @${appliedBy},\n  ` + `but @EagerInstantiate is trying to set a conflicting scope Container.\n  ` + `Only one decorator should set the class scope, or all must agree on the same value.`;
         });
         metadata.eagerInstantiate = true;
         metadata.scope = {
-            value: Scope.Container,
+            value: "Container",
             appliedBy: "EagerInstantiate"
         };
     };
 }
 
-// @internal
-function updateParameterMetadata(decorator, target, methodKey, parameterIndex, updateFn) {
-    // Error out immediately if the decorator has been applied to a static method
-    if (methodKey !== undefined && typeof target === "function") {
-        check(false, `@${decorator} cannot be used on static method ${target.name}.${String(methodKey)}`);
-    }
-    if (methodKey === undefined) {
-        // Constructor
-        const metadata = getMetadata(target);
-        const dependency = metadata.getCtorDependency(parameterIndex);
-        updateFn(dependency);
-    } else {
-        // Instance method
-        const metadata = getMetadata(target.constructor);
-        const dependency = metadata.getMethodDependency(methodKey, parameterIndex);
-        updateFn(dependency);
-    }
-}
-// Checks that a constructor or method parameter has only one injection decorator.
-// For example, if both `@Inject` and `@Optional` are used, it becomes difficult to
-// understand which one "wins", unless the user is aware of the decorator evaluation order.
-//
-// @internal
-function checkSingleDecorator(dependency, target, methodKey, parameterIndex) {
-    check(dependency.appliedBy === undefined, ()=>{
-        const param = describeParam(target, methodKey, parameterIndex);
-        return `multiple injection decorators on ${param}, but only one is allowed`;
-    });
-}
-// Checks that the `@Named` decorator is not used in combination with
-// `@InjectAll` or `@OptionalAll`, which ignore the name qualification.
-//
-// @internal
-function checkNamedDecorator(dependency, target, methodKey, parameterIndex) {
-    const { appliedBy, name } = dependency;
-    check(name === undefined || appliedBy !== "InjectAll" && appliedBy !== "OptionalAll", ()=>{
-        const param = describeParam(target, methodKey, parameterIndex);
-        return `@Named has no effect on ${param} when used with @${appliedBy}`;
-    });
-}
-// Returns a human-readable description of the parameter location.
-// For example: "Wizard constructor parameter 2" or "Wizard.set parameter 0"
-//
-// @internal
-function describeParam(target, methodKey, parameterIndex) {
-    const location = methodKey === undefined ? target.name : `${target.constructor.name}.${String(methodKey)}`;
-    return `${location}(parameter #${parameterIndex})`;
-}
-
 // @__NO_SIDE_EFFECTS__
 function Inject(token) {
     return function(target, propertyKey, parameterIndex) {
@@ -1215,7 +1262,7 @@ function OptionalAll(token) {
  *
  * @example
  * ```ts
- * @Scoped(Scope.Container)
+ * @Scoped("Container")
  * class Wizard {}
  *
  * container.register(Wizard);
@@ -1224,7 +1271,7 @@ function OptionalAll(token) {
  * container.register(
  *   Wizard,
  *   { useClass: Wizard },
- *   { scope: Scope.Container },
+ *   { scope: "Container" },
  * );
  * ```
  *
@@ -1238,7 +1285,7 @@ function OptionalAll(token) {
             const { value, appliedBy } = currentScope;
             const by = appliedBy === "Scoped" ? `another @${appliedBy} decorator` : `@${appliedBy}`;
             const className = getTokenName(ctor);
-            return `class ${className}: Scope.${value} was already set by ${by},\n  ` + `but @Scoped is trying to set a conflicting Scope.${scope}.\n  ` + `Only one decorator should set the class scope, or all must agree on the same value.`;
+            return `class ${className}: scope ${value} was already set by ${by},\n  ` + `but @Scoped is trying to set a conflicting scope ${scope}.\n  ` + `Only one decorator should set the class scope, or all must agree on the same value.`;
         });
         metadata.scope = {
             value: scope,
@@ -1248,21 +1295,23 @@ function OptionalAll(token) {
 }
 
 /**
- * Injector token for dynamic injections.
+ * Allows performing injections outside the normal injection context window.
  *
  * @example
  * ```ts
  * class Wizard {
  *   private injector = inject(Injector);
+ *
+ *   // Lazily initialize the wand property
  *   private wand?: Wand;
  *
  *   getWand(): Wand {
+ *     // An injection context does not exist here, but the
+ *     // Injector instance retains and reuse the context
+ *     // that was present at the time of its injection
  *     return (this.wand ??= this.injector.inject(Wand));
  *   }
  * }
- *
- * const wizard = container.resolve(Wizard);
- * wizard.getWand(); // => Wand
  * ```
  */ const Injector = /*@__PURE__*/ build(()=>{
     const context = ensureInjectionContext("Injector factory");
@@ -1286,46 +1335,22 @@ function OptionalAll(token) {
     };
 }, "Injector");
 
-/**
- * Applies middleware functions to a container.
- *
- * Middlewares are applied in array order but execute in reverse order.
- *
- * @example
- * ```ts
- * const container = applyMiddleware(
- *   createContainer(),
- *   [A, B],
- * );
- * ```
- *
- * The execution order will be:
- *
- * 1. B before
- * 2. A before
- * 3. original function
- * 4. A after
- * 5. B after
- *
- * This allows outer middlewares to wrap and control the behavior of inner middlewares.
- */ function applyMiddleware(container, middlewares) {
-    const composer = {
-        use (key, wrap) {
-            // We need to bind the 'this' context of the function to the container
-            // before passing it to the middleware wrapper.
-            const fn = container[key].bind(container);
-            container[key] = wrap(fn);
-            return composer;
-        }
-    };
-    const api = container.api ||= {
-        ...container
-    };
-    for (const middleware of middlewares){
-        middleware(composer, api);
-    }
-    return container;
-}
+const Scope = {
+    /**
+   * Creates a new value every time the token is resolved.
+   */ Transient: "Transient",
+    /**
+   * Creates and caches a single value per token resolution graph.
+   *
+   * The same value is reused during a single resolution request and is subsequently discarded.
+   */ Resolution: "Resolution",
+    /**
+   * Creates and caches a single value per container.
+   *
+   * If the value is not found in the current container, it is looked up in the parent container,
+   * and so on. It effectively behaves like a _singleton_ scope but allows container-specific overrides.
+   */ Container: "Container"
+};
 
 exports.AutoRegister = AutoRegister;
 exports.EagerInstantiate = EagerInstantiate;
@@ -1338,7 +1363,7 @@ exports.Optional = Optional;
 exports.OptionalAll = OptionalAll;
 exports.Scope = Scope;
 exports.Scoped = Scoped;
-exports.applyMiddleware = applyMiddleware;
+exports.assertInjectionContext = assertInjectionContext;
 exports.build = build;
 exports.classRef = classRef;
 exports.createContainer = createContainer;