@tachybase/di 1.3.43

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+import { Container } 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 type { Handler } from './interfaces/handler.interface';
+export type { ServiceMetadata } from './interfaces/service-metadata.interface';
+export type { ServiceOptions } from './interfaces/service-options.interface';
+export type { ServiceIdentifier } from './types/service-identifier.type';
+export { ContainerInstance, Container } from './container-instance.class';
+export { Token } from './token.class';
+export default Container;
+export * from './decorators';

package/lib/index.js

@@ -0,0 +1,50 @@
+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 index_exports = {};
+__export(index_exports, {
+  Container: () => import_container_instance2.Container,
+  ContainerInstance: () => import_container_instance2.ContainerInstance,
+  Token: () => import_token.Token,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_container_instance = require("./container-instance.class");
+__reExport(index_exports, require("./decorators/inject-many.decorator"), module.exports);
+__reExport(index_exports, require("./decorators/inject.decorator"), module.exports);
+__reExport(index_exports, require("./decorators/service.decorator"), module.exports);
+__reExport(index_exports, require("./error/cannot-inject-value.error"), module.exports);
+__reExport(index_exports, require("./error/cannot-instantiate-value.error"), module.exports);
+__reExport(index_exports, require("./error/service-not-found.error"), module.exports);
+var import_container_instance2 = require("./container-instance.class");
+var import_token = require("./token.class");
+__reExport(index_exports, require("./decorators"), module.exports);
+var index_default = import_container_instance.Container;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Container,
+  ContainerInstance,
+  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"),
+  ...require("./decorators")
+});

package/lib/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/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);

package/lib/interfaces/handler.interface.d.ts

@@ -0,0 +1,27 @@
+import { Constructable } from '@tachybase/utils';
+import { ContainerInstance } from '../container-instance.class';
+/**
+ * Used to register special "handler" which will be executed on a service class during its initialization.
+ * It can be used to create custom decorators and set/replace service class properties and constructor parameters.
+ */
+export interface Handler<T = unknown> {
+    /**
+     * Service object used to apply handler to.
+     */
+    object: Constructable<T>;
+    /**
+     * Class property name to set/replace value of.
+     * Used if handler is applied on a class property.
+     */
+    propertyName?: string;
+    /**
+     * Parameter index to set/replace value of.
+     * Used if handler is applied on a constructor parameter.
+     */
+    index?: number;
+    /**
+     * Factory function that produces value that will be set to class property or constructor parameter.
+     * Accepts container instance which requested the value.
+     */
+    value: (container: ContainerInstance) => any;
+}

package/lib/interfaces/handler.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 handler_interface_exports = {};
+module.exports = __toCommonJS(handler_interface_exports);

package/lib/interfaces/service-metadata.interface.d.ts

@@ -0,0 +1,53 @@
+import { Constructable } from '@tachybase/utils';
+import { ContainerInstance } from '../container-instance.class';
+import { ContainerIdentifier } from '../types/container-identifier.type';
+import { ContainerScope } from '../types/container-scope.type';
+import { ServiceIdentifier } from '../types/service-identifier.type';
+/**
+ * Service metadata is used to initialize service and store its state.
+ */
+export interface ServiceMetadata<Type = unknown> {
+    /** Unique identifier of the referenced service. */
+    id: ServiceIdentifier;
+    /**
+     * The injection scope for the service.
+     *   - a `singleton` service always will be created in the default container regardless of who registering it
+     *   - a `container` scoped service will be created once when requested from the given container
+     *   - a `transient` service will be created each time it is requested
+     */
+    scope: ContainerScope;
+    /**
+     * Class definition of the service what is used to initialize given service.
+     * This property maybe null if the value of the service is set manually.
+     * If id is not set then it serves as service id.
+     */
+    type: Constructable<Type> | null;
+    /**
+     * Factory function used to initialize this service.
+     * Can be regular function ("createCar" for example),
+     * or other service which produces this instance ([CarFactory, "createCar"] for example).
+     */
+    factory: [Constructable<unknown>, string] | CallableFunction | undefined;
+    /**
+     * Instance of the target class.
+     */
+    value: unknown | symbol;
+    /**
+     * Allows to setup multiple instances the different classes under a single service id string or token.
+     */
+    multiple: boolean;
+    /**
+     * Indicates whether a new instance should be created as soon as the class is registered.
+     * By default the registered classes are only instantiated when they are requested from the container.
+     *
+     * _Note: This option is ignored for transient services._
+     */
+    eager: boolean;
+    /**
+     * Map of containers referencing this metadata. This is used when a container
+     * is inheriting it's parents definitions and values to track the lifecycle of
+     * the metadata. Namely, a service can be disposed only if it's only referenced
+     * by the container being disposed.
+     */
+    referencedBy: Map<ContainerIdentifier, ContainerInstance>;
+}

package/lib/interfaces/service-metadata.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 service_metadata_interface_exports = {};
+module.exports = __toCommonJS(service_metadata_interface_exports);

package/lib/interfaces/service-options.interface.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMetadata } from './service-metadata.interface';
+/**
+ * The public ServiceOptions is partial object of ServiceMetadata and either one
+ * of the following is set: `type`, `factory`, `value` but not more than one.
+ */
+export type ServiceOptions<T = unknown> = Omit<Partial<ServiceMetadata<T>>, 'referencedBy' | 'type' | 'factory'> | Omit<Partial<ServiceMetadata<T>>, 'referencedBy' | 'value' | 'factory'> | Omit<Partial<ServiceMetadata<T>>, 'referencedBy' | 'value' | 'type'>;

package/lib/interfaces/service-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 service_options_interface_exports = {};
+module.exports = __toCommonJS(service_options_interface_exports);

package/lib/token.class.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Used to create unique typed service identifier.
+ * Useful when service has only interface, but don't have a class.
+ */
+export declare class Token<T> {
+    name?: string;
+    /**
+     * @param name Token name, optional and only used for debugging purposes.
+     */
+    constructor(name?: string);
+}

package/lib/token.class.js

@@ -0,0 +1,37 @@
+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 token_class_exports = {};
+__export(token_class_exports, {
+  Token: () => Token
+});
+module.exports = __toCommonJS(token_class_exports);
+const _Token = class _Token {
+  /**
+   * @param name Token name, optional and only used for debugging purposes.
+   */
+  constructor(name) {
+    this.name = name;
+  }
+};
+__name(_Token, "Token");
+let Token = _Token;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Token
+});

package/lib/types/abstract-constructable.type.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generic type for abstract class definitions.
+ *
+ * Explanation: This describes a newable Function with a prototype Which is
+ * what an abstract class is - no constructor, just the prototype.
+ */
+export type AbstractConstructable<T> = NewableFunction & {
+    prototype: T;
+};

package/lib/types/abstract-constructable.type.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 abstract_constructable_type_exports = {};
+module.exports = __toCommonJS(abstract_constructable_type_exports);

package/lib/types/container-identifier.type.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A container identifier. This value must be unique across all containers.
+ */
+export type ContainerIdentifier = string | symbol;

package/lib/types/container-identifier.type.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_identifier_type_exports = {};
+module.exports = __toCommonJS(container_identifier_type_exports);

package/lib/types/container-scope.type.d.ts

@@ -0,0 +1 @@
+export type ContainerScope = 'singleton' | 'container' | 'transient';

package/lib/types/container-scope.type.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_scope_type_exports = {};
+module.exports = __toCommonJS(container_scope_type_exports);

package/lib/types/service-identifier.type.d.ts

@@ -0,0 +1,8 @@
+import { Constructable } from '@tachybase/utils';
+import { Token } from '../token.class';
+import { AbstractConstructable } from './abstract-constructable.type';
+/**
+ * Unique service identifier.
+ * Can be some class type, or string id, or instance of Token.
+ */
+export type ServiceIdentifier<T = unknown> = Constructable<T> | AbstractConstructable<T> | CallableFunction | Token<T> | string;

package/lib/types/service-identifier.type.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 service_identifier_type_exports = {};
+module.exports = __toCommonJS(service_identifier_type_exports);

package/lib/utils/resolve-to-type-wrapper.util.d.ts

@@ -0,0 +1,15 @@
+import { Constructable } from '@tachybase/utils';
+import { ServiceIdentifier } from '../types/service-identifier.type';
+/**
+ * Helper function used in inject decorators to resolve the received identifier to
+ * an eager type when possible or to a lazy type when cyclic dependencies are possibly involved.
+ *
+ * @param typeOrIdentifier a service identifier or a function returning a type acting as service identifier or nothing
+ * @param target the class definition of the target of the decorator
+ * @param propertyName the name of the property in case of a PropertyDecorator
+ * @param index the index of the parameter in the constructor in case of ParameterDecorator
+ */
+export declare function resolveToTypeWrapper(typeOrIdentifier: ((type?: never) => Constructable<unknown>) | ServiceIdentifier<unknown> | undefined, target: object, propertyName: string | symbol, index?: number): {
+    eagerType: ServiceIdentifier | null;
+    lazyType: (type?: never) => ServiceIdentifier;
+};

package/lib/utils/resolve-to-type-wrapper.util.js

@@ -0,0 +1,39 @@
+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 resolve_to_type_wrapper_util_exports = {};
+__export(resolve_to_type_wrapper_util_exports, {
+  resolveToTypeWrapper: () => resolveToTypeWrapper
+});
+module.exports = __toCommonJS(resolve_to_type_wrapper_util_exports);
+var import_token = require("../token.class");
+function resolveToTypeWrapper(typeOrIdentifier, target, propertyName, index) {
+  let typeWrapper;
+  if (typeOrIdentifier && typeof typeOrIdentifier === "string" || typeOrIdentifier instanceof import_token.Token) {
+    typeWrapper = { eagerType: typeOrIdentifier, lazyType: /* @__PURE__ */ __name(() => typeOrIdentifier, "lazyType") };
+  }
+  if (typeOrIdentifier && typeof typeOrIdentifier === "function") {
+    typeWrapper = { eagerType: null, lazyType: /* @__PURE__ */ __name(() => typeOrIdentifier(), "lazyType") };
+  }
+  return typeWrapper;
+}
+__name(resolveToTypeWrapper, "resolveToTypeWrapper");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveToTypeWrapper
+});

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@tachybase/di",
+  "version": "1.3.43",
+  "description": "",
+  "license": "Apache-2.0",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "@tachybase/utils": "^1.3.42"
+  }
+}