@tachybase/di 1.3.43

package/lib/container-registry.class.d.ts

@@ -0,0 +1,51 @@
+import { ContainerInstance } from './container-instance.class';
+import { ContainerIdentifier } from './types/container-identifier.type';
+/**
+ * The container registry is responsible for holding the default and every
+ * created container instance for later access.
+ *
+ * _Note: This class is for internal use and it's API may break in minor or
+ * patch releases without warning._
+ */
+export declare class 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.
+     */
+    private static readonly containerMap;
+    /**
+     * 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: ContainerInstance): void;
+    /**
+     * Returns true if a container exists with the given ID or false otherwise.
+     *
+     * @param container the ID of the container
+     */
+    static hasContainer(id: ContainerIdentifier): boolean;
+    /**
+     * 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: ContainerIdentifier): ContainerInstance;
+    /**
+     * 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 removeContainer(container: ContainerInstance): Promise<void>;
+}

package/lib/container-registry.class.js

@@ -0,0 +1,95 @@
+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 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.
+ */
+_ContainerRegistry.containerMap = /* @__PURE__ */ new Map();
+let ContainerRegistry = _ContainerRegistry;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContainerRegistry
+});

package/lib/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/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/decorators/inject.decorator.d.ts

@@ -0,0 +1,9 @@
+import { Constructable } from '@tachybase/utils';
+import { Token } from '../token.class';
+/**
+ * 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/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/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/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/decorators.d.ts

@@ -0,0 +1,16 @@
+export interface ActionDef {
+    type: string;
+    resourceName?: string;
+    actionName?: string;
+    method?: string;
+    options?: {
+        acl?: 'loggedIn' | 'public' | 'private';
+    };
+}
+export declare function App(): Function;
+export declare function Db(): Function;
+export declare function InjectLog(): Function;
+export declare function Controller(name: string): (target: any, context: ClassDecoratorContext) => void;
+export declare function Action(name: string, options?: {
+    acl?: 'loggedIn' | 'public' | 'private';
+}): (_: any, context: ClassMethodDecoratorContext) => void;

package/lib/decorators.js

@@ -0,0 +1,86 @@
+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 decorators_exports = {};
+__export(decorators_exports, {
+  Action: () => Action,
+  App: () => App,
+  Controller: () => Controller,
+  Db: () => Db,
+  InjectLog: () => InjectLog
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_container_instance = require("./container-instance.class");
+var import_inject = require("./decorators/inject.decorator");
+var import_service = require("./decorators/service.decorator");
+import_container_instance.Container.set({ id: "actions", value: /* @__PURE__ */ new Map() });
+function App() {
+  return (0, import_inject.Inject)("app");
+}
+__name(App, "App");
+function Db() {
+  return (0, import_inject.Inject)("db");
+}
+__name(Db, "Db");
+function InjectLog() {
+  return (0, import_inject.Inject)("logger");
+}
+__name(InjectLog, "InjectLog");
+function Controller(name) {
+  return function(target, context) {
+    const serviceOptions = { id: "controller", multiple: true };
+    (0, import_service.Service)(serviceOptions)(target, context);
+    const actions = import_container_instance.Container.get("actions");
+    if (!actions.has(target)) {
+      actions.set(target, []);
+    }
+    actions.get(target).push({
+      type: "resource",
+      resourceName: name
+    });
+  };
+}
+__name(Controller, "Controller");
+function Action(name, options) {
+  return function(_, context) {
+    if (!context.metadata.injects) {
+      context.metadata.injects = [];
+    }
+    context.metadata.injects.push((target) => {
+      const actions = import_container_instance.Container.get("actions");
+      if (!actions.has(target)) {
+        actions.set(target, []);
+      }
+      actions.get(target).push({
+        type: "action",
+        method: String(context.name),
+        actionName: name,
+        options: options || { acl: "private" }
+      });
+    });
+  };
+}
+__name(Action, "Action");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Action,
+  App,
+  Controller,
+  Db,
+  InjectLog
+});

package/lib/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/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/error/cannot-inject-value.error.d.ts

@@ -0,0 +1,11 @@
+import { Constructable } from '@tachybase/utils';
+/**
+ * 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/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;
+    this.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/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/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 {
+  constructor(identifier) {
+    var _a, _b;
+    super();
+    this.name = "CannotInstantiateValueError";
+    /** Normalized identifier name used in the error message. */
+    this.normalizedIdentifier = "<UNKNOWN_IDENTIFIER>";
+    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}>`;
+    }
+  }
+  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.`;
+  }
+};
+__name(_CannotInstantiateValueError, "CannotInstantiateValueError");
+let CannotInstantiateValueError = _CannotInstantiateValueError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CannotInstantiateValueError
+});

package/lib/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/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 {
+  constructor(identifier) {
+    var _a, _b;
+    super();
+    this.name = "ServiceNotFoundError";
+    /** Normalized identifier name used in the error message. */
+    this.normalizedIdentifier = "<UNKNOWN_IDENTIFIER>";
+    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}>`;
+    }
+  }
+  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.`;
+  }
+};
+__name(_ServiceNotFoundError, "ServiceNotFoundError");
+let ServiceNotFoundError = _ServiceNotFoundError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServiceNotFoundError
+});