@expressots/core 3.0.0-beta.4 → 4.0.0-preview.1

package/lib/esm/di/binding-decorator/factory/module_factory.js

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import "reflect-metadata";
+import { METADATA_KEY } from "../constants.js";
+import { ContainerModule, } from "../../inversify.js";
+/**
+ * Builds a ContainerModule from all @provide() decorated classes.
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Behavior**
+ * - Discovers all classes decorated with @provide() or fluentProvide()
+ * - Creates bindings for each discovered provider
+ * - Returns ContainerModule that can be loaded into container
+ *
+ * **Used By**
+ * - AppContainer automatically loads this module
+ * - Provides auto-discovery of providers
+ *
+ * @returns ContainerModule with all provider bindings
+ *
+ * @internal
+ */
+function buildProviderModule() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return new ContainerModule((bind, unbind) => {
+        const provideMetadata = Reflect.getMetadata(METADATA_KEY.provide, Reflect) || [];
+        provideMetadata.map((metadata) => resolve(metadata, bind));
+    });
+}
+function resolve(metadata, bind) {
+    return metadata.constraint(bind, metadata.implementationType);
+}
+export default buildProviderModule;

package/lib/esm/di/binding-decorator/index.js

@@ -0,0 +1,10 @@
+import autoProvide from "./utils/auto_wire.js";
+import provide from "./decorator/provide.js";
+import fluentProvide from "./decorator/fluent_provide.js";
+import buildProviderModule from "./factory/module_factory.js";
+import { METADATA_KEY } from "./constants.js";
+export { fluentProvide };
+export { provide };
+export { autoProvide };
+export { buildProviderModule };
+export { METADATA_KEY };

package/lib/esm/di/binding-decorator/interfaces/interfaces.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/di/binding-decorator/syntax/provide_done_syntax.js

@@ -0,0 +1,41 @@
+import { decorate, injectable, METADATA_KEY as inversify_METADATA_KEY, } from "../../inversify.js";
+import { METADATA_KEY } from "../constants.js";
+class ProvideDoneSyntax {
+    _binding;
+    constructor(binding) {
+        this._binding = binding;
+    }
+    done(force) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const that = this;
+        return function (target) {
+            const isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_METADATA_KEY.PARAM_TYPES, target);
+            const redecorateWithInject = force === true;
+            if (redecorateWithInject === true && isAlreadyDecorated === false) {
+                decorate(injectable(), target);
+            }
+            else if (redecorateWithInject === true && isAlreadyDecorated === true) {
+                // Do nothing
+            }
+            else {
+                try {
+                    decorate(injectable(), target);
+                }
+                catch (e) {
+                    throw new Error("Cannot apply @fluentProvide decorator multiple times but is has been used " +
+                        `multiple times in ${target.name} ` +
+                        "Please use done(true) if you are trying to declare multiple bindings!");
+                }
+            }
+            const currentMetadata = {
+                constraint: that._binding,
+                implementationType: target,
+            };
+            const previousMetadata = Reflect.getMetadata(METADATA_KEY.provide, Reflect) || [];
+            const newMetadata = [currentMetadata, ...previousMetadata];
+            Reflect.defineMetadata(METADATA_KEY.provide, newMetadata, Reflect);
+            return target;
+        };
+    }
+}
+export default ProvideDoneSyntax;

package/lib/esm/di/binding-decorator/syntax/provide_in_syntax.js

@@ -0,0 +1,37 @@
+import ProvideWhenOnSyntax from "./provide_when_on_syntax.js";
+import ProvideWhenSyntax from "./provide_when_syntax.js";
+import ProvideOnSyntax from "./provide_on_syntax.js";
+import ProvideDoneSyntax from "./provide_done_syntax.js";
+class ProvideInSyntax {
+    _bindingInSyntax;
+    _provideDoneSyntax;
+    constructor(bindingInSyntax, provideDoneSyntax) {
+        this._bindingInSyntax = bindingInSyntax;
+        this._provideDoneSyntax = provideDoneSyntax;
+    }
+    inSingletonScope() {
+        const bindingWhenOnSyntax = (bind, target) => this._bindingInSyntax(bind, target).inSingletonScope();
+        const inDoneSyntax = new ProvideDoneSyntax(bindingWhenOnSyntax);
+        const provideWhenSyntax = new ProvideWhenSyntax(bindingWhenOnSyntax, inDoneSyntax);
+        const provideOnSyntax = new ProvideOnSyntax(bindingWhenOnSyntax, inDoneSyntax);
+        return new ProvideWhenOnSyntax(provideWhenSyntax, provideOnSyntax);
+    }
+    inTransientScope() {
+        const bindingWhenOnSyntax = (bind, target) => this._bindingInSyntax(bind, target).inTransientScope();
+        const inDoneSyntax = new ProvideDoneSyntax(bindingWhenOnSyntax);
+        const provideWhenSyntax = new ProvideWhenSyntax(bindingWhenOnSyntax, inDoneSyntax);
+        const provideOnSyntax = new ProvideOnSyntax(bindingWhenOnSyntax, inDoneSyntax);
+        return new ProvideWhenOnSyntax(provideWhenSyntax, provideOnSyntax);
+    }
+    inScope(scope) {
+        const bindingWhenOnSyntax = (bind, target) => this._bindingInSyntax(bind, target).inScope(scope);
+        const inDoneSyntax = new ProvideDoneSyntax(bindingWhenOnSyntax);
+        const provideWhenSyntax = new ProvideWhenSyntax(bindingWhenOnSyntax, inDoneSyntax);
+        const provideOnSyntax = new ProvideOnSyntax(bindingWhenOnSyntax, inDoneSyntax);
+        return new ProvideWhenOnSyntax(provideWhenSyntax, provideOnSyntax);
+    }
+    done(force) {
+        return this._provideDoneSyntax.done(force);
+    }
+}
+export default ProvideInSyntax;

package/lib/esm/di/binding-decorator/syntax/provide_in_when_on_syntax.js

@@ -0,0 +1,68 @@
+class ProvideInWhenOnSyntax {
+    _provideInSyntax;
+    _provideWhenSyntax;
+    _provideOnSyntax;
+    constructor(provideInSyntax, provideWhenSyntax, provideOnSyntax) {
+        this._provideInSyntax = provideInSyntax;
+        this._provideWhenSyntax = provideWhenSyntax;
+        this._provideOnSyntax = provideOnSyntax;
+    }
+    when(constraint) {
+        return this._provideWhenSyntax.when(constraint);
+    }
+    whenTargetNamed(name) {
+        return this._provideWhenSyntax.whenTargetNamed(name);
+    }
+    whenTargetTagged(tag, value) {
+        return this._provideWhenSyntax.whenTargetTagged(tag, value);
+    }
+    whenInjectedInto(parent) {
+        return this._provideWhenSyntax.whenInjectedInto(parent);
+    }
+    whenParentNamed(name) {
+        return this._provideWhenSyntax.whenParentNamed(name);
+    }
+    whenParentTagged(tag, value) {
+        return this._provideWhenSyntax.whenParentTagged(tag, value);
+    }
+    whenAnyAncestorIs(ancestor) {
+        return this._provideWhenSyntax.whenAnyAncestorIs(ancestor);
+    }
+    whenNoAncestorIs(ancestor) {
+        return this._provideWhenSyntax.whenNoAncestorIs(ancestor);
+    }
+    whenAnyAncestorNamed(name) {
+        return this._provideWhenSyntax.whenAnyAncestorNamed(name);
+    }
+    whenAnyAncestorTagged(tag, value) {
+        return this._provideWhenSyntax.whenAnyAncestorTagged(tag, value);
+    }
+    whenNoAncestorNamed(name) {
+        return this._provideWhenSyntax.whenNoAncestorNamed(name);
+    }
+    whenNoAncestorTagged(tag, value) {
+        return this._provideWhenSyntax.whenNoAncestorTagged(tag, value);
+    }
+    whenAnyAncestorMatches(constraint) {
+        return this._provideWhenSyntax.whenAnyAncestorMatches(constraint);
+    }
+    whenNoAncestorMatches(constraint) {
+        return this._provideWhenSyntax.whenNoAncestorMatches(constraint);
+    }
+    onActivation(fn) {
+        return this._provideOnSyntax.onActivation(fn);
+    }
+    inSingletonScope() {
+        return this._provideInSyntax.inSingletonScope();
+    }
+    inTransientScope() {
+        return this._provideInSyntax.inTransientScope();
+    }
+    inScope(scope) {
+        return this._provideInSyntax.inScope(scope);
+    }
+    done(force) {
+        return this._provideInSyntax.done(force);
+    }
+}
+export default ProvideInWhenOnSyntax;

package/lib/esm/di/binding-decorator/syntax/provide_on_syntax.js

@@ -0,0 +1,19 @@
+import ProvideWhenSyntax from "./provide_when_syntax.js";
+import ProvideDoneSyntax from "./provide_done_syntax.js";
+class ProvideOnSyntax {
+    _bindingOnSyntax;
+    _provideDoneSyntax;
+    constructor(bindingOnSyntax, provideDoneSyntax) {
+        this._bindingOnSyntax = bindingOnSyntax;
+        this._provideDoneSyntax = provideDoneSyntax;
+    }
+    onActivation(fn) {
+        const bindingWhenSyntax = (bind, target) => this._bindingOnSyntax(bind, target).onActivation(fn);
+        const onDoneSyntax = new ProvideDoneSyntax(bindingWhenSyntax);
+        return new ProvideWhenSyntax(bindingWhenSyntax, onDoneSyntax);
+    }
+    done(force) {
+        return this._provideDoneSyntax.done(force);
+    }
+}
+export default ProvideOnSyntax;

package/lib/esm/di/binding-decorator/syntax/provide_when_on_syntax.js

@@ -0,0 +1,57 @@
+class ProvideWhenOnSyntax {
+    _provideWhenSyntax;
+    _provideOnSyntax;
+    constructor(provideWhenSyntax, provideOnSyntax) {
+        this._provideWhenSyntax = provideWhenSyntax;
+        this._provideOnSyntax = provideOnSyntax;
+    }
+    when(constraint) {
+        return this._provideWhenSyntax.when(constraint);
+    }
+    whenTargetNamed(name) {
+        return this._provideWhenSyntax.whenTargetNamed(name);
+    }
+    whenTargetTagged(tag, value) {
+        return this._provideWhenSyntax.whenTargetTagged(tag, value);
+    }
+    whenInjectedInto(parent) {
+        return this._provideWhenSyntax.whenInjectedInto(parent);
+    }
+    whenParentNamed(name) {
+        return this._provideWhenSyntax.whenParentNamed(name);
+    }
+    whenParentTagged(tag, value) {
+        return this._provideWhenSyntax.whenParentTagged(tag, value);
+    }
+    whenAnyAncestorIs(ancestor) {
+        return this._provideWhenSyntax.whenAnyAncestorIs(ancestor);
+    }
+    whenNoAncestorIs(ancestor) {
+        return this._provideWhenSyntax.whenNoAncestorIs(ancestor);
+    }
+    whenAnyAncestorNamed(name) {
+        return this._provideWhenSyntax.whenAnyAncestorNamed(name);
+    }
+    whenAnyAncestorTagged(tag, value) {
+        return this._provideWhenSyntax.whenAnyAncestorTagged(tag, value);
+    }
+    whenNoAncestorNamed(name) {
+        return this._provideWhenSyntax.whenNoAncestorNamed(name);
+    }
+    whenNoAncestorTagged(tag, value) {
+        return this._provideWhenSyntax.whenNoAncestorTagged(tag, value);
+    }
+    whenAnyAncestorMatches(constraint) {
+        return this._provideWhenSyntax.whenAnyAncestorMatches(constraint);
+    }
+    whenNoAncestorMatches(constraint) {
+        return this._provideWhenSyntax.whenNoAncestorMatches(constraint);
+    }
+    onActivation(fn) {
+        return this._provideOnSyntax.onActivation(fn);
+    }
+    done(force) {
+        return this._provideWhenSyntax.done(force);
+    }
+}
+export default ProvideWhenOnSyntax;

package/lib/esm/di/binding-decorator/syntax/provide_when_syntax.js

@@ -0,0 +1,86 @@
+import ProvideOnSyntax from "./provide_on_syntax.js";
+import ProvideDoneSyntax from "./provide_done_syntax.js";
+class ProvideWhenSyntax {
+    _bindingWhenSyntax;
+    _provideDoneSyntax;
+    constructor(bindingWhenSyntax, provideDoneSyntax) {
+        this._bindingWhenSyntax = bindingWhenSyntax;
+        this._provideDoneSyntax = provideDoneSyntax;
+    }
+    when(constraint) {
+        const bindingOnSyntax = (bind, target) => {
+            return this._bindingWhenSyntax(bind, target).when(constraint);
+        };
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenTargetNamed(name) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenTargetNamed(name);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenTargetTagged(tag, value) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenTargetTagged(tag, value);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenInjectedInto(parent) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenInjectedInto(parent);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenParentNamed(name) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenParentNamed(name);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenParentTagged(tag, value) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenParentTagged(tag, value);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenAnyAncestorIs(ancestor) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenAnyAncestorIs(ancestor);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenNoAncestorIs(ancestor) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenNoAncestorIs(ancestor);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenAnyAncestorNamed(name) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenAnyAncestorNamed(name);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenAnyAncestorTagged(tag, value) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenAnyAncestorTagged(tag, value);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenNoAncestorNamed(name) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenNoAncestorNamed(name);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenNoAncestorTagged(tag, value) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenNoAncestorTagged(tag, value);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenAnyAncestorMatches(constraint) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenAnyAncestorMatches(constraint);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenNoAncestorMatches(constraint) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenNoAncestorMatches(constraint);
+        const whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
+    }
+    done(force) {
+        return this._provideDoneSyntax.done(force);
+    }
+}
+export default ProvideWhenSyntax;

package/lib/esm/di/binding-decorator/utils/auto_wire.js

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { decorate } from "../../inversify.js";
+import provide from "../decorator/provide.js";
+function autoProvide(container, ...modules) {
+    modules.forEach((module) => {
+        Object.keys(module).forEach((key) => {
+            const entity = module[key];
+            const decorator = provide(entity);
+            decorate(decorator, entity);
+        });
+    });
+}
+export default autoProvide;

package/lib/esm/di/bindings/binding.js

@@ -0,0 +1,64 @@
+import { Scope, BindingTypeEnum } from "../constants/literal_types.js";
+import { id } from "../utils/id.js";
+class Binding {
+    id;
+    moduleId;
+    // Determines weather the bindings has been already activated
+    // The activation action takes place when an instance is resolved
+    // If the scope is singleton it only happens once
+    activated;
+    // A runtime identifier because at runtime we don't have interfaces
+    serviceIdentifier;
+    // constructor from binding to or toConstructor
+    implementationType;
+    // Cache used to allow singleton scope and BindingType.ConstantValue bindings
+    cache;
+    // Cache used to allow BindingType.DynamicValue bindings
+    dynamicValue;
+    // The scope mode to be used
+    scope;
+    // The kind of binding
+    type;
+    // A factory method used in BindingType.Factory bindings
+    factory;
+    // An async factory method used in BindingType.Provider bindings
+    provider;
+    // A constraint used to limit the contexts in which this binding is applicable
+    constraint;
+    // On activation handler (invoked just before an instance is added to cache and injected)
+    onActivation;
+    // On deactivation handler (invoked just before an instance is unbinded and removed from container)
+    onDeactivation;
+    constructor(serviceIdentifier, scope) {
+        this.id = id();
+        this.activated = false;
+        this.serviceIdentifier = serviceIdentifier;
+        this.scope = scope;
+        this.type = BindingTypeEnum.Invalid;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        this.constraint = (request) => true;
+        this.implementationType = null;
+        this.cache = null;
+        this.factory = null;
+        this.provider = null;
+        this.onActivation = null;
+        this.onDeactivation = null;
+        this.dynamicValue = null;
+    }
+    clone() {
+        const clone = new Binding(this.serviceIdentifier, this.scope);
+        clone.activated = clone.scope === Scope.Singleton ? this.activated : false;
+        clone.implementationType = this.implementationType;
+        clone.dynamicValue = this.dynamicValue;
+        clone.scope = this.scope;
+        clone.type = this.type;
+        clone.factory = this.factory;
+        clone.provider = this.provider;
+        clone.constraint = this.constraint;
+        clone.onActivation = this.onActivation;
+        clone.onDeactivation = this.onDeactivation;
+        clone.cache = this.cache;
+        return clone;
+    }
+}
+export { Binding };

package/lib/esm/di/bindings/binding_count.js

@@ -0,0 +1,5 @@
+export const BindingCount = {
+    MultipleBindingsAvailable: 2,
+    NoBindingsAvailable: 0,
+    OnlyOneBindingAvailable: 1,
+};

package/lib/esm/di/constants/error_msgs.js

@@ -0,0 +1,54 @@
+export const DUPLICATED_INJECTABLE_DECORATOR = "Cannot apply @injectable decorator multiple times.";
+export const DUPLICATED_METADATA = "Metadata key was used more than once in a parameter:";
+export const NULL_ARGUMENT = "NULL argument";
+export const KEY_NOT_FOUND = "Key Not Found";
+export const AMBIGUOUS_MATCH = "Ambiguous match found for serviceIdentifier:";
+export const CANNOT_UNBIND = "Could not unbind serviceIdentifier:";
+export const NOT_REGISTERED = "No matching bindings found for serviceIdentifier:";
+export const MISSING_INJECTABLE_ANNOTATION = "Missing required @injectable annotation in:";
+export const MISSING_INJECT_ANNOTATION = "Missing required @inject or @multiInject annotation in:";
+export const UNDEFINED_INJECT_ANNOTATION = (name) => `@inject called with undefined this could mean that the class ${name} has ` +
+    "a circular dependency problem. You can use a LazyServiceIdentifer to " +
+    "overcome this limitation.";
+export const CIRCULAR_DEPENDENCY = "Circular dependency found:";
+export const NOT_IMPLEMENTED = "Sorry, this feature is not fully implemented yet.";
+export const INVALID_BINDING_TYPE = "Invalid binding type:";
+export const NO_MORE_SNAPSHOTS_AVAILABLE = "No snapshot available to restore.";
+export const INVALID_MIDDLEWARE_RETURN = "Invalid return type in middleware. Middleware must return!";
+export const INVALID_FUNCTION_BINDING = "Value provided to function binding must be a function!";
+export const LAZY_IN_SYNC = (key) => `You are attempting to construct ${keyToString(key)} in a synchronous way ` +
+    "but it has asynchronous dependencies.";
+export const INVALID_TO_SELF_VALUE = "The toSelf function can only be applied when a constructor is " +
+    "used as service identifier";
+export const INVALID_DECORATOR_OPERATION = "The @inject @multiInject @tagged and @named decorators " +
+    "must be applied to the parameters of a class constructor or a class property.";
+export const ARGUMENTS_LENGTH_MISMATCH = (...values) => "The number of constructor arguments in the derived class " +
+    `${values[0]} must be >= than the number of constructor arguments of its base class.`;
+export const CONTAINER_OPTIONS_MUST_BE_AN_OBJECT = "Invalid Container constructor argument. Container options " +
+    "must be an object.";
+export const CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE = "Invalid Container option. Default scope must " +
+    'be a string ("singleton" or "transient").';
+export const CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE = "Invalid Container option. Auto bind injectable must " + "be a boolean";
+export const CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK = "Invalid Container option. Skip base check must " + "be a boolean";
+export const MULTIPLE_PRE_DESTROY_METHODS = "Cannot apply @preDestroy decorator multiple times in the same class";
+export const MULTIPLE_POST_CONSTRUCT_METHODS = "Cannot apply @postConstruct decorator multiple times in the same class";
+export const ASYNC_UNBIND_REQUIRED = "Attempting to unbind dependency with asynchronous destruction (@preDestroy or onDeactivation)";
+export const POST_CONSTRUCT_ERROR = (clazz, errorMessage) => `@postConstruct error in class ${clazz}: ${errorMessage}`;
+export const PRE_DESTROY_ERROR = (clazz, errorMessage) => `@preDestroy error in class ${clazz}: ${errorMessage} ` +
+    `Lifecycle hooks (@preDestroy / onDeactivation) only fire for singleton-scoped bindings. ` +
+    `Use @provideSingleton(${clazz}) instead of @provide(${clazz}), or remove @preDestroy if the class is meant to be request- or transient-scoped.`;
+export const ON_DEACTIVATION_ERROR = (clazz, errorMessage) => `onDeactivation() error in class ${clazz}: ${errorMessage} ` +
+    `onDeactivation handlers only fire for singleton-scoped bindings. ` +
+    `Use @provideSingleton(${clazz}) instead of @provide(${clazz}), or remove the onDeactivation handler if the class is meant to be request- or transient-scoped.`;
+export const CIRCULAR_DEPENDENCY_IN_FACTORY = (factoryType, serviceIdentifier) => `It looks like there is a circular dependency in one of the '${factoryType}' bindings. Please investigate bindings with ` +
+    `service identifier '${serviceIdentifier}'.`;
+export const STACK_OVERFLOW = "Maximum call stack size exceeded";
+function keyToString(key) {
+    if (typeof key === "function") {
+        return `[function/class ${key.name || "<anonymous>"}]`;
+    }
+    if (typeof key === "symbol") {
+        return key.toString();
+    }
+    return `'${key}'`;
+}

package/lib/esm/di/constants/literal_types.js

@@ -0,0 +1,21 @@
+const Scope = {
+    Request: "Request",
+    Singleton: "Singleton",
+    Transient: "Transient",
+};
+const BindingTypeEnum = {
+    ConstantValue: "ConstantValue",
+    Constructor: "Constructor",
+    DynamicValue: "DynamicValue",
+    Factory: "Factory",
+    Function: "Function",
+    Instance: "Instance",
+    Invalid: "Invalid",
+    Provider: "Provider",
+};
+const TargetTypeEnum = {
+    ClassProperty: "ClassProperty",
+    ConstructorArgument: "ConstructorArgument",
+    Variable: "Variable",
+};
+export { Scope, BindingTypeEnum, TargetTypeEnum };

package/lib/esm/di/constants/metadata_keys.js

@@ -0,0 +1,35 @@
+// Used for named bindings
+export const NAMED_TAG = "named";
+// The name of the target at design time
+export const NAME_TAG = "name";
+// The for unmanaged injections (in base classes when using inheritance)
+export const UNMANAGED_TAG = "unmanaged";
+// The for optional injections
+export const OPTIONAL_TAG = "optional";
+// The type of the binding at design time
+export const INJECT_TAG = "inject";
+// The type of the binding at design type for multi-injections
+export const MULTI_INJECT_TAG = "multi_inject";
+// used to store constructor arguments tags
+export const TAGGED = "inversify:tagged";
+// used to store class properties tags
+export const TAGGED_PROP = "inversify:tagged_props";
+// used to store types to be injected
+export const PARAM_TYPES = "inversify:paramtypes";
+// used to access design time types
+export const DESIGN_PARAM_TYPES = "design:paramtypes";
+// used to identify postConstruct functions
+export const POST_CONSTRUCT = "post_construct";
+// used to identify preDestroy functions
+export const PRE_DESTROY = "pre_destroy";
+function getNonCustomTagKeys() {
+    return [
+        INJECT_TAG,
+        MULTI_INJECT_TAG,
+        NAME_TAG,
+        UNMANAGED_TAG,
+        NAMED_TAG,
+        OPTIONAL_TAG,
+    ];
+}
+export const NON_CUSTOM_TAG_KEYS = getNonCustomTagKeys();