@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/esm/lib/core/Container.js

@@ -0,0 +1,629 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { createContainer } from '../ioc/DependencyInjectionContainer.js';
+import { __destroy, BaseObject } from '../base/BaseObject.js';
+import { constructorSymbol } from '../ioc/ConstructorSymbol.js';
+import { LoadObjectOptions, OBJECT_ID } from '../../options/LoadObjectOptions.js';
+import { asClass, asValue } from '../ioc/Resolvers.js';
+import { getObjectLifetime } from '../ioc/ObjectLifetime.js';
+import { getConfigurableRecords, getRegistrationNameFromInstance, setConfigurableRecords, setConfigurableRecordsToInstance, setIdToInstance } from '../base/internal/ConfigurableRecordsInjection.js';
+import { DTO } from '../dto/DTO.js';
+import { getObjectIsAutoload } from '../base/internal/ObjectInjection.js';
+import { Accept } from '../../decorators/dto/Accept.js';
+import { listModules } from '../ioc/ListModules.js';
+import { pathToFileURL } from 'url';
+import { isClass } from '../ioc/Utils.js';
+import { MODULE_INITIALIZATION } from '../base/internal/ModuleInitialization.js';
+import { waitForObjectStartup } from '../base/internal/ObjectStartup.js';
+import { reportDestroyError } from '../foundation/LifecycleErrorReporter.js';
+import { throwWarning } from '../foundation/ThrowWarning.js';
+import { isSubclassOf } from '@lakutata/utils/IsSubclassOf';
+import { ObjectDestroyedException } from '../../exceptions/ObjectDestroyedException.js';
+import { As } from '@lakutata/utils/As';
+import { isEmptyObject } from '@lakutata/utils/IsEmptyObject';
+import { appendObjectWeakRefs, clearObjectWeakRefs, getObjectWeakRefs } from '../ioc/ObjectWeakRefs.js';
+export const containerSymbol = Symbol('LAKUTATA.DI.CONTAINER.SYMBOL');
+export const ownerSymbol = Symbol('LAKUTATA.DI.OWNER.SYMBOL');
+//The hooks run before the teardown of a container, by container
+const teardownHooks = new WeakMap();
+/**
+ * Register a hook run when a container starts its teardown, before its scopes and objects are destroyed
+ * (an entrypoint stops receiving requests and waits for the requests in progress there), returns its unregistration
+ * @param container
+ * @param hook
+ */
+export function registerTeardownHook(container, hook) {
+    let hooks = teardownHooks.get(container);
+    if (!hooks)
+        teardownHooks.set(container, hooks = new Set());
+    hooks.add(hook);
+    return () => void hooks.delete(hook);
+}
+/**
+ * The dependency injection container: it registers the classes of the objects (components, providers, modules, any
+ * {@link BaseObject}), creates them on demand with their lifetime and destroys them with itself.
+ *
+ * An object is created asynchronously: its `@Inject` properties are resolved from the container, its `@Configurable`
+ * properties get their configured values (validated and transformed by their schemas), then its `init()` runs; the
+ * promise of `get()`, `set()` or `build()` settles once `init()` has completed. The lifetime of the class decides
+ * which instance is returned:
+ * - `@Singleton` (components, modules): one instance, held by the container which registered the class.
+ * - `@Scoped` (providers): one instance per scope (see {@link Container.createScope}), such as per request.
+ * - `@Transient` ({@link BaseObject}): a new instance on each request.
+ *
+ * The applications rarely create a container: the {@link Application} owns the root one, each object owns a child
+ * container tracking the objects it creates (destroyed with it), and the modules and components reach theirs through
+ * their protected `container` property. A container created with `new Container()` is a root container, to use the
+ * objects without an application (tests, scripts).
+ * @example
+ * ```typescript
+ * import {Component, Container, DTO, Provider} from 'lakutata'
+ * import {Configurable, Inject} from 'lakutata/decorator/di'
+ *
+ * class Greeter extends Provider {
+ *     //'Hello' unless configured
+ *     @Configurable(DTO.String())
+ *     protected readonly greeting: string = 'Hello'
+ *
+ *     public greet(name: string): string {
+ *         return `${this.greeting}, ${name}`
+ *     }
+ * }
+ *
+ * class Reception extends Component {
+ *     @Inject('greeter')
+ *     protected readonly greeter!: Greeter
+ *
+ *     public welcome(name: string): string {
+ *         return this.greeter.greet(name)
+ *     }
+ * }
+ *
+ * const container: Container = new Container()
+ * await container.registerNamed('greeter', Greeter, {greeting: 'Welcome'})
+ * const reception: Reception = await container.set(Reception)
+ * console.log(reception.welcome('Ada')) //Welcome, Ada
+ * await container.destroy()
+ * ```
+ */
+export class Container {
+    #dic;
+    /**
+     * Removes the weak reference of a garbage collected sub object container from its parent
+     * @private
+     */
+    static #releasedContainerRegistry = new FinalizationRegistry(({ refs, ref }) => refs.delete(ref));
+    /**
+     * Sub scopes are held strongly, a scope lives until it is destroyed explicitly or together with its parent
+     * @private
+     */
+    #subScopeSet;
+    /**
+     * Containers of sub objects are held weakly, they live as long as their owner objects
+     * @private
+     */
+    #subObjectContainerRefs;
+    #selfRef;
+    #destroyed;
+    #destroyPromise;
+    /**
+     * Whether current container is a scope (the root container or one created by createScope()),
+     * an object's own container is not a scope, it only tracks the objects created by that object
+     * @private
+     */
+    #isScope;
+    /**
+     * Create a container. Without parent, a root container; with a parent, a container whose registrations fall back
+     * to the parent's, destroyed together with it.
+     * @param parent The parent container, none for a root container.
+     * @param owner The object owning the container (the framework gives each object its own container).
+     */
+    constructor(parent, owner) {
+        /**
+         * Sub scopes are held strongly, a scope lives until it is destroyed explicitly or together with its parent
+         * @private
+         */
+        this.#subScopeSet = new Set();
+        /**
+         * Containers of sub objects are held weakly, they live as long as their owner objects
+         * @private
+         */
+        this.#subObjectContainerRefs = new Set();
+        this.#selfRef = new WeakRef(this);
+        this.#destroyed = false;
+        /**
+         * The names registered by this container itself (not by its parents); a singleton is resolved by the container
+         * which registered it, a scoped object by the nearest scope.
+         * @protected
+         */
+        this.injectionNames = new Set();
+        this.parent = parent;
+        this.#isScope = !parent;
+        this.#dic = parent ? parent.#dic.createScope() : createContainer({
+            //strict must be false
+            strict: false
+        });
+        if (this.parent)
+            Container.#releasedContainerRegistry.register(this, {
+                refs: this.parent.#subObjectContainerRefs,
+                ref: this.#selfRef
+            });
+        this.#attachToParent();
+        this.#dic.register(containerSymbol, asValue(this));
+        if (owner)
+            this.#dic.register(ownerSymbol, asValue(new WeakRef(owner)));
+    }
+    /**
+     * Let the parent track current container, so it is destroyed together with its parent
+     * @private
+     */
+    #attachToParent() {
+        if (!this.parent)
+            return;
+        if (this.#isScope) {
+            this.parent.#subScopeSet.add(this);
+        }
+        else {
+            this.parent.#subObjectContainerRefs.add(this.#selfRef);
+        }
+    }
+    /**
+     * Create the resolver of a registration
+     * @param target
+     * @private
+     */
+    #createResolver(target) {
+        return asClass(target, As(this.buildResolverOptions(target)));
+    }
+    /**
+     * Throw if current container has been destroyed (or is being destroyed)
+     * @private
+     */
+    #assertNotDestroyed() {
+        if (this.#destroyed)
+            throw new ObjectDestroyedException('The container has been destroyed');
+    }
+    /**
+     * Get the nearest scope, starting from current container
+     * @private
+     */
+    #nearestScope() {
+        let container = this;
+        while (!container.#isScope && container.parent)
+            container = container.parent;
+        return container;
+    }
+    /**
+     * Get the root container, the one without parent
+     * @private
+     */
+    #root() {
+        let container = this;
+        while (container.parent)
+            container = container.parent;
+        return container;
+    }
+    /**
+     * Stop being tracked by the parent
+     * @private
+     */
+    #detachFromParent() {
+        if (!this.parent)
+            return;
+        this.parent.#subScopeSet.delete(this);
+        this.parent.#subObjectContainerRefs.delete(this.#selfRef);
+    }
+    /**
+     * Destroy an object of the container during its teardown: its `beforeDestroy()`, the objects it created, then its
+     * `destroy()`. Never throws: the errors are reported through the application's logger.
+     * @param instance The object to destroy.
+     * @returns Resolves once the object is destroyed.
+     * @protected
+     */
+    async disposer(instance) {
+        try {
+            await instance.getMethod(__destroy, false)();
+        }
+        catch (e) {
+            //Cascaded destruction never throws, errors are reported instead
+            reportDestroyError(e, instance.className);
+        }
+    }
+    /**
+     * The options of the resolver of a class: the lifetime declared by its decorators (`@Singleton`, `@Scoped`,
+     * `@Transient`) and its disposer ({@link Container.disposer}).
+     * @param target The class to register or build.
+     * @returns The resolver options.
+     * @protected
+     */
+    buildResolverOptions(target) {
+        const objectLifetime = getObjectLifetime(target);
+        return {
+            lifetime: objectLifetime,
+            dispose: (instance) => this.disposer(instance)
+        };
+    }
+    /**
+     * Give an object just created by the container its registration name and its options: the options it was
+     * registered with, overridden by the ones requested. An object already created (a cached singleton or scoped
+     * instance) is returned as it is, the options requested being ignored with a warning outside production.
+     * @param resolved The object, or the promise of its asynchronous construction.
+     * @param registrationName The name (or class symbol) the object was requested by.
+     * @param configurableRecords The options requested for the object.
+     * @returns The object, once constructed.
+     * @protected
+     */
+    async processResolved(resolved, registrationName, configurableRecords = {}) {
+        //Only a newly created object gets its id and configurable records, a cached one is already initialized
+        const isSubBaseObject = isSubclassOf(resolved?.constructor, BaseObject);
+        const isNewSubBaseObject = isSubBaseObject && getRegistrationNameFromInstance(As(resolved)) === undefined;
+        if (isSubBaseObject && !isNewSubBaseObject && !isEmptyObject(configurableRecords) && process.env.NODE_ENV !== 'production') {
+            throwWarning(`The configuration passed for the already created object "${As(resolved).className}" is ignored. Use a scoped or transient object to get an instance with its own configuration.`);
+        }
+        if (isNewSubBaseObject) {
+            const presetConfigurableRecords = getConfigurableRecords(As(resolved.constructor), registrationName);
+            //set id into object instance
+            setIdToInstance(As(resolved), registrationName);
+            //set configurable records into object instance
+            setConfigurableRecordsToInstance(As(resolved), { ...presetConfigurableRecords, ...configurableRecords });
+        }
+        return Promise.resolve(resolved);
+    }
+    /**
+     * Build the registration of an object declaration: its name is its id (the name it is declared under) or, without
+     * id, a symbol of its class; its other options are kept as the options it is created with.
+     * @param options The object declaration.
+     * @returns The registration, keyed by its name.
+     * @protected
+     */
+    buildNameAndRegistrationPairFromOptions(options) {
+        const pair = {};
+        const id = options[OBJECT_ID] ? options[OBJECT_ID] : constructorSymbol(options.class);
+        const configurableRecords = { ...options, class: void (0) };
+        delete configurableRecords.id;
+        delete configurableRecords.class;
+        setConfigurableRecords(options.class, id, configurableRecords);
+        pair[id] = this.#createResolver(options.class);
+        return pair;
+    }
+    /**
+     * Build the registrations of the classes found by a glob pattern: each file matched is imported, and each of its
+     * exports which is a {@link BaseObject} subclass is registered under the symbol of its class.
+     * @param glob The glob pattern of the files to import, relative to the working directory (the aliases are not
+     * replaced in it).
+     * @returns The registrations, keyed by their class symbols.
+     * @throws {Error} When a file matched fails to import (its error as the cause).
+     * @protected
+     */
+    async buildNameAndRegistrationPairFromGlob(glob) {
+        const pairs = await Promise.all(listModules(glob).map(async (moduleDescriptor) => {
+            let importResult;
+            try {
+                importResult = await import(pathToFileURL(moduleDescriptor.path).toString());
+            }
+            catch (error) {
+                throw new Error(`The file ${moduleDescriptor.path} matched by "${glob}" cannot be imported: ${error?.message ?? error}`, { cause: error });
+            }
+            const pair = {};
+            for (const exportObj of Object.values(importResult)) {
+                if (isClass(exportObj) && isSubclassOf(exportObj, BaseObject))
+                    pair[constructorSymbol(exportObj)] = this.#createResolver(As(exportObj));
+            }
+            return pair;
+        }));
+        return Object.assign({}, ...pairs);
+    }
+    /**
+     * The object owning the container (the one whose container it is, or the owner of the container a scope was
+     * created from).
+     * @returns The owner, or undefined for a container without owner or whose owner was garbage collected.
+     */
+    owner() {
+        const owner = this.#dic.resolve(ownerSymbol, { allowUnregistered: true });
+        return owner ? owner.deref() : undefined;
+    }
+    /**
+     * Register objects in the container, without creating them: a class is registered under the symbol of its class
+     * (got by its class), a declaration with an id under its id (got by its name) with its options, a glob pattern
+     * registers the classes of the files it matches. A name registered again replaces the previous registration.
+     * @param options The classes, declarations (`{class, ...options}`) and glob patterns to register.
+     * @returns Resolves once registered (the glob patterns imported).
+     * @throws {InvalidMethodAcceptException} When an item is neither a class, a declaration nor a glob pattern.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     * @throws {Error} When a file matched by a glob pattern fails to import.
+     */
+    async load(options) {
+        this.#assertNotDestroyed();
+        let pair = {};
+        const buildNameAndRegistrationPairFromGlobPromises = [];
+        options.forEach((value) => {
+            if (typeof value === 'string') {
+                //glob
+                buildNameAndRegistrationPairFromGlobPromises.push(this.buildNameAndRegistrationPairFromGlob(value));
+            }
+            else if (isClass(As(value))) {
+                const loadObjectOptions = { class: As(value) };
+                pair = { ...pair, ...this.buildNameAndRegistrationPairFromOptions(loadObjectOptions) };
+            }
+            else {
+                //load options
+                const loadObjectOptions = As(value);
+                pair = { ...pair, ...this.buildNameAndRegistrationPairFromOptions(loadObjectOptions) };
+            }
+        });
+        if (buildNameAndRegistrationPairFromGlobPromises.length) {
+            const pairs = await Promise.all(buildNameAndRegistrationPairFromGlobPromises);
+            pairs.forEach((_pair) => {
+                pair = { ..._pair, ...pair };
+            });
+        }
+        if (!isEmptyObject(pair)) {
+            Object.getOwnPropertyNames(pair).forEach(value => this.injectionNames.add(value));
+            Object.getOwnPropertySymbols(pair).forEach(value => this.injectionNames.add(value));
+            this.#dic.register(pair);
+        }
+    }
+    async get(inp, configurableRecords = {}) {
+        return await this.#get(inp, configurableRecords, false);
+    }
+    async getShared(inp, configurableRecords = {}) {
+        return await this.#get(inp, configurableRecords, true);
+    }
+    /**
+     * Get a registered object
+     * @param inp
+     * @param configurableRecords
+     * @param shared whether a scoped object requested with a configuration is the shared instance
+     * @private
+     */
+    async #get(inp, configurableRecords, shared) {
+        const registrationName = typeof inp === 'function' ? constructorSymbol(inp) : inp;
+        this.#assertNotDestroyed();
+        if (!this.#dic.hasRegistration(registrationName) && typeof inp === 'function' && getObjectIsAutoload(As(inp))) {
+            //An autoloaded scoped object is registered in the nearest scope, so it is shared within the request;
+            //an autoloaded singleton in the root container, so it is shared by every object of the application
+            const lifetime = As(getObjectLifetime(As(inp)));
+            const registerContainer = lifetime === 'SCOPED' ? this.#nearestScope() : lifetime === 'SINGLETON' ? this.#root() : this;
+            await registerContainer.load([{
+                    id: registrationName,
+                    class: As(inp)
+                }]);
+        }
+        const registration = this.#dic.getRegistration(registrationName);
+        const lifetime = registration?.lifetime;
+        //A scoped object requested with its own configuration is a new instance owned by the requester, it is not cached,
+        //so it never replaces the instance shared within the request (unless the shared instance is requested)
+        if (!shared && registration && lifetime === 'SCOPED' && !isEmptyObject(configurableRecords)) {
+            const configured = await this.processResolved(this.#dic.build(registration), registrationName, configurableRecords);
+            appendObjectWeakRefs(this.#dic, configured);
+            await waitForObjectStartup(configured);
+            return configured;
+        }
+        let resolver = this;
+        if (lifetime === 'SINGLETON') {
+            //Singletons are resolved by the container which registered them
+            while (!resolver.injectionNames.has(registrationName) && resolver.parent)
+                resolver = resolver.parent;
+        }
+        else if (lifetime === 'SCOPED') {
+            //Scoped objects are resolved by the nearest scope (one instance per request), or by the container which registered them
+            while (!resolver.injectionNames.has(registrationName) && !resolver.#isScope && resolver.parent)
+                resolver = resolver.parent;
+        }
+        resolver.#assertNotDestroyed();
+        const object = await resolver.processResolved(resolver.#dic.resolve(registrationName), registrationName, configurableRecords);
+        await this.#waitForModule(object);
+        await waitForObjectStartup(object);
+        return object;
+    }
+    /**
+     * Wait for the initialization of a module resolved for an object outside it (its objects loaded, its bootstrap
+     * run); the module itself and its objects, created by its initialization, do not wait for it
+     * @param object
+     * @private
+     */
+    async #waitForModule(object) {
+        const initialization = object?.[MODULE_INITIALIZATION];
+        if (typeof initialization !== 'function')
+            return;
+        for (let container = this; container; container = container.parent)
+            if (container.owner() === object)
+                return;
+        await initialization.call(object);
+    }
+    has(inp) {
+        if (typeof inp === 'function')
+            return this.#dic.hasRegistration(constructorSymbol(inp));
+        return this.#dic.hasRegistration(inp);
+    }
+    /**
+     * Register a class (unless it is registered already) and get its object, as {@link Container.get}.
+     * @param target The class.
+     * @param configurableRecords The options of the object: registered with the class when it is registered now, and
+     * requested for the object.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     * @throws {Error} When the object fails to be created.
+     */
+    async set(target, configurableRecords = {}) {
+        if (!this.has(target)) {
+            await this.load([{
+                    ...configurableRecords,
+                    class: target
+                }]);
+        }
+        return await this.get(target, {
+            ...configurableRecords
+        });
+    }
+    /**
+     * Register a class under a name, replacing a previous registration of the name, and get its object.
+     * @param name The registration name or symbol.
+     * @param target The class.
+     * @param configurableRecords The options the object is registered with.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     * @throws {Error} When the object fails to be created.
+     */
+    async setNamed(name, target, configurableRecords = {}) {
+        await this.load([{
+                ...configurableRecords,
+                class: target,
+                [OBJECT_ID]: name
+            }]);
+        return await this.get(name);
+    }
+    /**
+     * Register a class by its class, without creating its object; a class registered again replaces its previous
+     * registration.
+     * @param target The class.
+     * @param configurableRecords The options its objects are created with.
+     * @returns Resolves once registered.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     */
+    async register(target, configurableRecords = {}) {
+        await this.load([{
+                ...configurableRecords,
+                class: target
+            }]);
+    }
+    /**
+     * Register a class under a name, without creating its object; a name registered again replaces its previous
+     * registration.
+     * @param name The registration name or symbol.
+     * @param target The class.
+     * @param configurableRecords The options its objects are created with.
+     * @returns Resolves once registered.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     */
+    async registerNamed(name, target, configurableRecords = {}) {
+        await this.load([{
+                ...configurableRecords,
+                class: target,
+                [OBJECT_ID]: name
+            }]);
+    }
+    /**
+     * Create a new object of a class without registering it, whatever its lifetime: its dependencies are injected
+     * from this container, and it is destroyed with this container (unless disposed before).
+     * @param target The class, registered or not.
+     * @param configurableRecords The options of the object.
+     * @returns The new object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     * @throws {Error} When the object fails to be created.
+     */
+    async build(target, configurableRecords = {}) {
+        this.#assertNotDestroyed();
+        const builtObject = await this.processResolved(this.#dic.build(target, this.buildResolverOptions(target)), constructorSymbol(target), configurableRecords);
+        appendObjectWeakRefs(this.#dic, builtObject);
+        await waitForObjectStartup(builtObject);
+        return builtObject;
+    }
+    /**
+     * Create a scope: a child container holding its own instances of the scoped objects (one per scope, such as one per
+     * request), the singletons and registrations of this container being shared. The scope lives until it is destroyed
+     * explicitly, or together with this container.
+     * @returns The new scope.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     */
+    createScope() {
+        this.#assertNotDestroyed();
+        const scope = new Container(this, this.owner());
+        scope.#detachFromParent();
+        scope.#isScope = true;
+        scope.#attachToParent();
+        return scope;
+    }
+    /**
+     * Track this container in its parent again, so it is destroyed together with the parent (used when its owner is
+     * initialized again).
+     */
+    registerContainerToItsParent() {
+        this.#attachToParent();
+    }
+    /**
+     * Make a destroyed container usable again, when its owner is reloaded.
+     * @throws {ObjectDestroyedException} When the parent container has been destroyed (or is being destroyed).
+     */
+    revive() {
+        if (this.parent && this.parent.#destroyed)
+            throw new ObjectDestroyedException('Cannot revive a container whose parent container has been destroyed');
+        this.#destroyed = false;
+        this.#destroyPromise = undefined;
+        this.#attachToParent();
+    }
+    /**
+     * Drop the cached instance of a registration, so the next request creates a new one; nothing happens when the
+     * cached instance is not the one given.
+     * @param name The registration name or symbol.
+     * @param instance The instance to drop.
+     */
+    forget(name, instance) {
+        const cached = this.#dic.cache.get(name);
+        if (cached && cached.value === instance)
+            this.#dic.cache.delete(name);
+    }
+    /**
+     * Destroy the container's objects and scopes, the container remaining usable: the teardown hooks run (the
+     * entrypoints stop), then the scopes and the containers of the objects are destroyed, then the cached objects and
+     * the transient objects still alive. Never throws: the errors are reported through the application's logger, and a
+     * failing object does not stop the teardown of the others.
+     * @returns Resolves once everything is destroyed.
+     */
+    async clear() {
+        //Every step always runs to the end, a failing object never stops the teardown of the others
+        const hooks = teardownHooks.get(this);
+        if (hooks?.size) {
+            const results = await Promise.allSettled([...hooks].map((hook) => hook()));
+            results.forEach((result) => result.status === 'rejected' && reportDestroyError(result.reason));
+        }
+        const subContainers = [...this.#subScopeSet];
+        this.#subObjectContainerRefs.forEach((ref) => {
+            const subContainer = ref.deref();
+            if (subContainer)
+                subContainers.push(subContainer);
+        });
+        await Promise.all(subContainers.map((subContainer) => subContainer.destroy()));
+        try {
+            await this.#dic.dispose();
+        }
+        catch (e) {
+            reportDestroyError(e);
+        }
+        const transients = [];
+        getObjectWeakRefs(this.#dic).forEach((ref) => {
+            const transient = ref.deref();
+            if (transient)
+                transients.push(transient);
+        });
+        await Promise.all(transients.map((transient) => this.disposer(transient)));
+        clearObjectWeakRefs(this.#dic);
+    }
+    /**
+     * Destroy the container: as {@link Container.clear}, then the container refuses any further request with an
+     * {@link ObjectDestroyedException}. A concurrent or repeated call waits for the same teardown.
+     * @returns Resolves once the container is destroyed.
+     */
+    async destroy() {
+        //A teardown already in progress is awaited, not skipped
+        if (this.#destroyPromise)
+            return await this.#destroyPromise;
+        this.#destroyed = true;
+        this.#detachFromParent();
+        this.#destroyPromise = this.clear();
+        await this.#destroyPromise;
+    }
+}
+__decorate([
+    Accept(DTO.Array(DTO.Alternatives(LoadObjectOptions.Schema(), DTO.Class(() => BaseObject), DTO.Glob()))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], Container.prototype, "load", null);