@tachybase/utils 0.23.8

package/lib/typedi/container-registry.class.js

@@ -0,0 +1,97 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var container_registry_class_exports = {};
+__export(container_registry_class_exports, {
+  ContainerRegistry: () => ContainerRegistry
+});
+module.exports = __toCommonJS(container_registry_class_exports);
+var import_container_instance = require("./container-instance.class");
+const _ContainerRegistry = class _ContainerRegistry {
+  /**
+   * Registers the given container instance or throws an error.
+   *
+   * _Note: This function is auto-called when a Container instance is created,
+   * it doesn't need to be called manually!_
+   *
+   * @param container the container to add to the registry
+   */
+  static registerContainer(container) {
+    if (container instanceof import_container_instance.ContainerInstance === false) {
+      throw new Error("Only ContainerInstance instances can be registered.");
+    }
+    if (_ContainerRegistry.containerMap.has(container.id)) {
+      throw new Error("Cannot register container with same ID.");
+    }
+    _ContainerRegistry.containerMap.set(container.id, container);
+  }
+  /**
+   * Returns true if a container exists with the given ID or false otherwise.
+   *
+   * @param container the ID of the container
+   */
+  static hasContainer(id) {
+    return _ContainerRegistry.containerMap.has(id);
+  }
+  /**
+   * Returns the container for requested ID or throws an error if no container
+   * is registered with the given ID.
+   *
+   * @param container the ID of the container
+   */
+  static getContainer(id) {
+    const registeredContainer = this.containerMap.get(id);
+    if (registeredContainer === void 0) {
+      throw new Error("No container is registered with the given ID.");
+    }
+    return registeredContainer;
+  }
+  /**
+   * Removes the given container from the registry and disposes all services
+   * registered only in this container.
+   *
+   * This function throws an error if no
+   *   - container exists with the given ID
+   *   - any of the registered services threw an error during it's disposal
+   *
+   * @param container the container to remove from the registry
+   */
+  static async removeContainer(container) {
+    const registeredContainer = _ContainerRegistry.containerMap.get(container.id);
+    if (registeredContainer === void 0) {
+      throw new Error("No container is registered with the given ID.");
+    }
+    _ContainerRegistry.containerMap.delete(container.id);
+    await registeredContainer.dispose();
+  }
+};
+__name(_ContainerRegistry, "ContainerRegistry");
+/**
+ * The list of all known container. Created containers are automatically added
+ * to this list. Two container cannot be registered with the same ID.
+ *
+ * This map doesn't contains the default container.
+ */
+__publicField(_ContainerRegistry, "containerMap", /* @__PURE__ */ new Map());
+let ContainerRegistry = _ContainerRegistry;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContainerRegistry
+});

package/lib/typedi/decorators/inject-many.decorator.d.ts

@@ -0,0 +1,8 @@
+import { Token } from '../token.class';
+/**
+ * Injects a list of services into a class property or constructor parameter.
+ */
+export declare function InjectMany(): Function;
+export declare function InjectMany(type?: (type?: any) => Function): Function;
+export declare function InjectMany(serviceName?: string): Function;
+export declare function InjectMany(token: Token<any>): Function;

package/lib/typedi/decorators/inject-many.decorator.js

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inject_many_decorator_exports = {};
+__export(inject_many_decorator_exports, {
+  InjectMany: () => InjectMany
+});
+module.exports = __toCommonJS(inject_many_decorator_exports);
+var import_container_instance = require("../container-instance.class");
+var import_cannot_inject_value = require("../error/cannot-inject-value.error");
+var import_resolve_to_type_wrapper = require("../utils/resolve-to-type-wrapper.util");
+function InjectMany(typeOrIdentifier) {
+  return function(_, context) {
+    if (!context.metadata.injects) {
+      context.metadata.injects = [];
+    }
+    context.metadata.injects.push((target) => {
+      const propertyName = context.name;
+      const typeWrapper = (0, import_resolve_to_type_wrapper.resolveToTypeWrapper)(typeOrIdentifier, target, propertyName);
+      if (typeWrapper === void 0 || typeWrapper.eagerType === void 0 || typeWrapper.eagerType === Object) {
+        throw new import_cannot_inject_value.CannotInjectValueError(target, propertyName);
+      }
+      import_container_instance.ContainerInstance.default.registerHandler({
+        object: target,
+        propertyName,
+        value: /* @__PURE__ */ __name((containerInstance) => {
+          const evaluatedLazyType = typeWrapper.lazyType();
+          if (evaluatedLazyType === void 0 || evaluatedLazyType === Object) {
+            throw new import_cannot_inject_value.CannotInjectValueError(target, propertyName);
+          }
+          return containerInstance.getMany(evaluatedLazyType);
+        }, "value")
+      });
+    });
+  };
+}
+__name(InjectMany, "InjectMany");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InjectMany
+});

package/lib/typedi/decorators/inject.decorator.d.ts

@@ -0,0 +1,9 @@
+import { Token } from '../token.class';
+import { Constructable } from '../types/constructable.type';
+/**
+ * Injects a service into a class property or constructor parameter.
+ */
+export declare function Inject(): Function;
+export declare function Inject(typeFn: (type?: never) => Constructable<unknown>): Function;
+export declare function Inject(serviceName?: string): Function;
+export declare function Inject(token: Token<unknown>): Function;

package/lib/typedi/decorators/inject.decorator.js

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inject_decorator_exports = {};
+__export(inject_decorator_exports, {
+  Inject: () => Inject
+});
+module.exports = __toCommonJS(inject_decorator_exports);
+var import_container_instance = require("../container-instance.class");
+var import_cannot_inject_value = require("../error/cannot-inject-value.error");
+var import_resolve_to_type_wrapper = require("../utils/resolve-to-type-wrapper.util");
+function Inject(typeOrIdentifier) {
+  return function(_, context) {
+    if (!context.metadata.injects) {
+      context.metadata.injects = [];
+    }
+    context.metadata.injects.push((target) => {
+      const propertyName = context.name;
+      const typeWrapper = (0, import_resolve_to_type_wrapper.resolveToTypeWrapper)(typeOrIdentifier, target, propertyName);
+      if (typeWrapper === void 0 || typeWrapper.eagerType === void 0 || typeWrapper.eagerType === Object) {
+        throw new import_cannot_inject_value.CannotInjectValueError(target, propertyName);
+      }
+      import_container_instance.ContainerInstance.default.registerHandler({
+        object: target,
+        propertyName,
+        value: /* @__PURE__ */ __name((containerInstance) => {
+          const evaluatedLazyType = typeWrapper.lazyType();
+          if (evaluatedLazyType === void 0 || evaluatedLazyType === Object) {
+            throw new import_cannot_inject_value.CannotInjectValueError(target, propertyName);
+          }
+          return containerInstance.get(evaluatedLazyType);
+        }, "value")
+      });
+    });
+  };
+}
+__name(Inject, "Inject");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Inject
+});

package/lib/typedi/decorators/service.decorator.d.ts

@@ -0,0 +1,6 @@
+import { ServiceOptions } from '../interfaces/service-options.interface';
+/**
+ * Marks class as a service that can be injected using Container.
+ */
+export declare function Service<T = unknown>(): Function;
+export declare function Service<T = unknown>(options: ServiceOptions<T>): Function;

package/lib/typedi/decorators/service.decorator.js

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var service_decorator_exports = {};
+__export(service_decorator_exports, {
+  Service: () => Service
+});
+module.exports = __toCommonJS(service_decorator_exports);
+var import_container_instance = require("../container-instance.class");
+var import_empty = require("../empty.const");
+function Service(options = {}) {
+  return (target, context) => {
+    const serviceMetadata = {
+      id: options.id || target,
+      type: target,
+      factory: options.factory || void 0,
+      multiple: options.multiple || false,
+      eager: options.eager || false,
+      scope: options.scope || "container",
+      referencedBy: (/* @__PURE__ */ new Map()).set(import_container_instance.ContainerInstance.default.id, import_container_instance.ContainerInstance.default),
+      value: import_empty.EMPTY_VALUE
+    };
+    (context.metadata.injects || []).forEach((inject) => {
+      inject(target);
+    });
+    import_container_instance.ContainerInstance.default.set(serviceMetadata);
+    return target;
+  };
+}
+__name(Service, "Service");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Service
+});

package/lib/typedi/empty.const.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Indicates that a service has not been initialized yet.
+ *
+ * _Note: This value is for internal use only._
+ */
+export declare const EMPTY_VALUE: unique symbol;

package/lib/typedi/empty.const.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var empty_const_exports = {};
+__export(empty_const_exports, {
+  EMPTY_VALUE: () => EMPTY_VALUE
+});
+module.exports = __toCommonJS(empty_const_exports);
+const EMPTY_VALUE = Symbol("EMPTY_VALUE");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMPTY_VALUE
+});

package/lib/typedi/error/cannot-inject-value.error.d.ts

@@ -0,0 +1,11 @@
+import { Constructable } from '../types/constructable.type';
+/**
+ * Thrown when DI cannot inject value into property decorated by @Inject decorator.
+ */
+export declare class CannotInjectValueError extends Error {
+    private target;
+    private propertyName;
+    name: string;
+    get message(): string;
+    constructor(target: Constructable<unknown>, propertyName: string);
+}

package/lib/typedi/error/cannot-inject-value.error.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cannot_inject_value_error_exports = {};
+__export(cannot_inject_value_error_exports, {
+  CannotInjectValueError: () => CannotInjectValueError
+});
+module.exports = __toCommonJS(cannot_inject_value_error_exports);
+const _CannotInjectValueError = class _CannotInjectValueError extends Error {
+  constructor(target, propertyName) {
+    super();
+    this.target = target;
+    this.propertyName = propertyName;
+  }
+  name = "CannotInjectValueError";
+  get message() {
+    return `Cannot inject value into "${this.target.constructor.name}.${this.propertyName}". Please make sure you setup reflect-metadata properly and you don't use interfaces without service tokens as injection value.`;
+  }
+};
+__name(_CannotInjectValueError, "CannotInjectValueError");
+let CannotInjectValueError = _CannotInjectValueError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CannotInjectValueError
+});

package/lib/typedi/error/cannot-instantiate-value.error.d.ts

@@ -0,0 +1,11 @@
+import { ServiceIdentifier } from '../types/service-identifier.type';
+/**
+ * Thrown when DI cannot inject value into property decorated by @Inject decorator.
+ */
+export declare class CannotInstantiateValueError extends Error {
+    name: string;
+    /** Normalized identifier name used in the error message. */
+    private normalizedIdentifier;
+    get message(): string;
+    constructor(identifier: ServiceIdentifier);
+}

package/lib/typedi/error/cannot-instantiate-value.error.js

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cannot_instantiate_value_error_exports = {};
+__export(cannot_instantiate_value_error_exports, {
+  CannotInstantiateValueError: () => CannotInstantiateValueError
+});
+module.exports = __toCommonJS(cannot_instantiate_value_error_exports);
+var import_token = require("../token.class");
+const _CannotInstantiateValueError = class _CannotInstantiateValueError extends Error {
+  name = "CannotInstantiateValueError";
+  /** Normalized identifier name used in the error message. */
+  normalizedIdentifier = "<UNKNOWN_IDENTIFIER>";
+  get message() {
+    return `Cannot instantiate the requested value for the "${this.normalizedIdentifier}" identifier. The related metadata doesn't contain a factory or a type to instantiate.`;
+  }
+  constructor(identifier) {
+    var _a, _b;
+    super();
+    if (typeof identifier === "string") {
+      this.normalizedIdentifier = identifier;
+    } else if (identifier instanceof import_token.Token) {
+      this.normalizedIdentifier = `Token<${identifier.name || "UNSET_NAME"}>`;
+    } else if (identifier && (identifier.name || ((_a = identifier.prototype) == null ? void 0 : _a.name))) {
+      this.normalizedIdentifier = identifier.name ? `MaybeConstructable<${identifier.name}>` : `MaybeConstructable<${(_b = identifier.prototype) == null ? void 0 : _b.name}>`;
+    }
+  }
+};
+__name(_CannotInstantiateValueError, "CannotInstantiateValueError");
+let CannotInstantiateValueError = _CannotInstantiateValueError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CannotInstantiateValueError
+});

package/lib/typedi/error/service-not-found.error.d.ts

@@ -0,0 +1,11 @@
+import { ServiceIdentifier } from '../types/service-identifier.type';
+/**
+ * Thrown when requested service was not found.
+ */
+export declare class ServiceNotFoundError extends Error {
+    name: string;
+    /** Normalized identifier name used in the error message. */
+    private normalizedIdentifier;
+    get message(): string;
+    constructor(identifier: ServiceIdentifier);
+}

package/lib/typedi/error/service-not-found.error.js

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var service_not_found_error_exports = {};
+__export(service_not_found_error_exports, {
+  ServiceNotFoundError: () => ServiceNotFoundError
+});
+module.exports = __toCommonJS(service_not_found_error_exports);
+var import_token = require("../token.class");
+const _ServiceNotFoundError = class _ServiceNotFoundError extends Error {
+  name = "ServiceNotFoundError";
+  /** Normalized identifier name used in the error message. */
+  normalizedIdentifier = "<UNKNOWN_IDENTIFIER>";
+  get message() {
+    return `Service with "${this.normalizedIdentifier}" identifier was not found in the container. Register it before usage via explicitly calling the "Container.set" function or using the "@Service()" decorator.`;
+  }
+  constructor(identifier) {
+    var _a, _b;
+    super();
+    if (typeof identifier === "string") {
+      this.normalizedIdentifier = identifier;
+    } else if (identifier instanceof import_token.Token) {
+      this.normalizedIdentifier = `Token<${identifier.name || "UNSET_NAME"}>`;
+    } else if (identifier && (identifier.name || ((_a = identifier.prototype) == null ? void 0 : _a.name))) {
+      this.normalizedIdentifier = identifier.name ? `MaybeConstructable<${identifier.name}>` : `MaybeConstructable<${(_b = identifier.prototype) == null ? void 0 : _b.name}>`;
+    }
+  }
+};
+__name(_ServiceNotFoundError, "ServiceNotFoundError");
+let ServiceNotFoundError = _ServiceNotFoundError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServiceNotFoundError
+});

package/lib/typedi/index.d.ts

@@ -0,0 +1,17 @@
+import { ContainerInstance } from './container-instance.class';
+export * from './decorators/inject-many.decorator';
+export * from './decorators/inject.decorator';
+export * from './decorators/service.decorator';
+export * from './error/cannot-inject-value.error';
+export * from './error/cannot-instantiate-value.error';
+export * from './error/service-not-found.error';
+export { Handler } from './interfaces/handler.interface';
+export { ServiceMetadata } from './interfaces/service-metadata.interface';
+export { ServiceOptions } from './interfaces/service-options.interface';
+export { Constructable } from './types/constructable.type';
+export { ServiceIdentifier } from './types/service-identifier.type';
+export { ContainerInstance } from './container-instance.class';
+export { Token } from './token.class';
+/** We export the default container under the Container alias. */
+export declare const Container: ContainerInstance;
+export default Container;

package/lib/typedi/index.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var typedi_exports = {};
+__export(typedi_exports, {
+  Constructable: () => import_constructable.Constructable,
+  Container: () => Container,
+  ContainerInstance: () => import_container_instance2.ContainerInstance,
+  Handler: () => import_handler.Handler,
+  ServiceIdentifier: () => import_service_identifier.ServiceIdentifier,
+  ServiceMetadata: () => import_service_metadata.ServiceMetadata,
+  ServiceOptions: () => import_service_options.ServiceOptions,
+  Token: () => import_token.Token,
+  default: () => typedi_default
+});
+module.exports = __toCommonJS(typedi_exports);
+var import_container_instance = require("./container-instance.class");
+__reExport(typedi_exports, require("./decorators/inject-many.decorator"), module.exports);
+__reExport(typedi_exports, require("./decorators/inject.decorator"), module.exports);
+__reExport(typedi_exports, require("./decorators/service.decorator"), module.exports);
+__reExport(typedi_exports, require("./error/cannot-inject-value.error"), module.exports);
+__reExport(typedi_exports, require("./error/cannot-instantiate-value.error"), module.exports);
+__reExport(typedi_exports, require("./error/service-not-found.error"), module.exports);
+var import_handler = require("./interfaces/handler.interface");
+var import_service_metadata = require("./interfaces/service-metadata.interface");
+var import_service_options = require("./interfaces/service-options.interface");
+var import_constructable = require("./types/constructable.type");
+var import_service_identifier = require("./types/service-identifier.type");
+var import_container_instance2 = require("./container-instance.class");
+var import_token = require("./token.class");
+const Container = import_container_instance.ContainerInstance.default;
+var typedi_default = Container;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Constructable,
+  Container,
+  ContainerInstance,
+  Handler,
+  ServiceIdentifier,
+  ServiceMetadata,
+  ServiceOptions,
+  Token,
+  ...require("./decorators/inject-many.decorator"),
+  ...require("./decorators/inject.decorator"),
+  ...require("./decorators/service.decorator"),
+  ...require("./error/cannot-inject-value.error"),
+  ...require("./error/cannot-instantiate-value.error"),
+  ...require("./error/service-not-found.error")
+});

package/lib/typedi/interfaces/container-options.interface.d.ts

@@ -0,0 +1,45 @@
+export interface ContainerOptions {
+    /**
+     * Controls the behavior when a service is already registered with the same ID. The following values are allowed:
+     *
+     *   - `throw` - a `ContainerCannotBeCreatedError` error is raised
+     *   - `overwrite` - the previous container is disposed and a new one is created
+     *   - `returnExisting` - returns the existing container or raises a `ContainerCannotBeCreatedError` error if the
+     *      specified options differ from the options of the existing container
+     *
+     * The default value is `returnExisting`.
+     */
+    onConflict: 'throw' | 'overwrite' | 'returnExisting';
+    /**
+     * Controls the behavior when a requested type doesn't exists in the current container. The following values are allowed:
+     *
+     *   - `allowLookup` - the parent container will be checked for the dependency
+     *   - `localOnly` - a `ServiceNotFoundError` error is raised
+     *
+     * The default value is `allowLookup`.
+     */
+    lookupStrategy: 'allowLookup' | 'localOnly';
+    /**
+     * Enables the lookup for global (singleton) services before checking in the current container. By default every
+     * type is first checked in the default container to return singleton services. This check bypasses the lookup strategy,
+     * set in the container so if this behavior is not desired it can be disabled via this flag.
+     *
+     * The default value is `true`.
+     */
+    allowSingletonLookup: boolean;
+    /**
+     * Controls how the child container inherits the service definitions from it's parent. The following values are allowed:
+     *
+     *  - `none` - no metadata is inherited
+     *  - `definitionOnly` - only metadata is inherited, a new instance will be created for each class
+     *    - eager classes created as soon as the container is created
+     *    - non-eager classes are created the first time they are requested
+     *  - `definitionWithValues` - both metadata and service instances are inherited
+     *    - when parent class is disposed the instances in this container are preserved
+     *    - if a service is registered but not created yet, it will be shared when created between the two container
+     *    - newly registered services won't be shared between the two container
+     *
+     * The default value is `none`.
+     */
+    inheritanceStrategy: 'none' | 'definitionOnly' | 'definitionWithValues';
+}

package/lib/typedi/interfaces/container-options.interface.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var container_options_interface_exports = {};
+module.exports = __toCommonJS(container_options_interface_exports);