@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/cjs/options/LoadAnonymousObjectOptions.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadAnonymousObjectOptions = void 0;
+const DTO_js_1 = require("../lib/dto/DTO.js");
+const BaseObject_js_1 = require("../lib/base/BaseObject.js");
+const Expect_js_1 = require("../decorators/dto/Expect.js");
+const IndexSignature_js_1 = require("../decorators/dto/IndexSignature.js");
+/**
+ * The declaration of an anonymous object in the `objects.anonymous` module option: its class and its options. The
+ * object is registered by its class (got with `getObject(TheClass)` or `@Inject(TheClass)`), with its options; the
+ * keys other than `class` are its options (the values of its `@Configurable` properties).
+ * @example
+ * ```typescript
+ * import {Application, BaseObject, DTO, type LoadAnonymousObjectOptions} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Mailer extends BaseObject {
+ *     @Configurable(DTO.String())
+ *     protected readonly host: string = 'localhost'
+ * }
+ *
+ * const mailer: LoadAnonymousObjectOptions = {class: Mailer, host: 'smtp.example.com'}
+ *
+ * Application.run({
+ *     id: 'mail.app',
+ *     name: 'Mail',
+ *     objects: {
+ *         anonymous: [mailer]
+ *     }
+ * })
+ * ```
+ */
+let LoadAnonymousObjectOptions = class LoadAnonymousObjectOptions extends DTO_js_1.DTO {
+};
+exports.LoadAnonymousObjectOptions = LoadAnonymousObjectOptions;
+__decorate([
+    (0, Expect_js_1.Expect)(DTO_js_1.DTO.Class(() => BaseObject_js_1.BaseObject).required()),
+    __metadata("design:type", Object)
+], LoadAnonymousObjectOptions.prototype, "class", void 0);
+exports.LoadAnonymousObjectOptions = LoadAnonymousObjectOptions = __decorate([
+    (0, IndexSignature_js_1.IndexSignature)(DTO_js_1.DTO.Any())
+], LoadAnonymousObjectOptions);

package/dist/cjs/options/LoadNamedObjectOptions.d.ts

@@ -0,0 +1,29 @@
+import { DTO } from '../lib/dto/DTO.js';
+import { LoadObjectOptions } from './LoadObjectOptions.js';
+/**
+ * The named objects of the `objects.named` module option: each declaration (its class and its options, see
+ * {@link LoadObjectOptions}) under the name the object is registered under (got with `getObject('name')` or
+ * `@Inject('name')`). A module is declared here.
+ * @example
+ * ```typescript
+ * import {Application, BaseObject, type LoadNamedObjectOptions} from 'lakutata'
+ *
+ * class Cart extends BaseObject {
+ * }
+ *
+ * const named: LoadNamedObjectOptions = {
+ *     cart: {class: Cart}
+ * }
+ *
+ * Application.run({
+ *     id: 'shop.app',
+ *     name: 'Shop',
+ *     objects: {
+ *         named: named
+ *     }
+ * })
+ * ```
+ */
+export declare class LoadNamedObjectOptions extends DTO {
+    [id: string]: LoadObjectOptions;
+}

package/dist/cjs/options/LoadNamedObjectOptions.js

@@ -0,0 +1,42 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadNamedObjectOptions = void 0;
+const DTO_js_1 = require("../lib/dto/DTO.js");
+const LoadObjectOptions_js_1 = require("./LoadObjectOptions.js");
+const IndexSignature_js_1 = require("../decorators/dto/IndexSignature.js");
+/**
+ * The named objects of the `objects.named` module option: each declaration (its class and its options, see
+ * {@link LoadObjectOptions}) under the name the object is registered under (got with `getObject('name')` or
+ * `@Inject('name')`). A module is declared here.
+ * @example
+ * ```typescript
+ * import {Application, BaseObject, type LoadNamedObjectOptions} from 'lakutata'
+ *
+ * class Cart extends BaseObject {
+ * }
+ *
+ * const named: LoadNamedObjectOptions = {
+ *     cart: {class: Cart}
+ * }
+ *
+ * Application.run({
+ *     id: 'shop.app',
+ *     name: 'Shop',
+ *     objects: {
+ *         named: named
+ *     }
+ * })
+ * ```
+ */
+let LoadNamedObjectOptions = class LoadNamedObjectOptions extends DTO_js_1.DTO {
+};
+exports.LoadNamedObjectOptions = LoadNamedObjectOptions;
+exports.LoadNamedObjectOptions = LoadNamedObjectOptions = __decorate([
+    (0, IndexSignature_js_1.IndexSignature)(LoadObjectOptions_js_1.LoadObjectOptions.Schema())
+], LoadNamedObjectOptions);

package/dist/cjs/options/LoadObjectOptions.d.ts

@@ -0,0 +1,30 @@
+import { DTO } from '../lib/dto/DTO.js';
+import { BaseObject } from '../lib/base/BaseObject.js';
+export declare const OBJECT_ID: unique symbol;
+/**
+ * The declaration of an object given to `Container.load()` and in the `objects.named` module option: its class and its
+ * options (the keys other than `class`, the values of its `@Configurable` properties).
+ * @example
+ * ```typescript
+ * import {BaseObject, Container, DTO, type LoadObjectOptions} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Mailer extends BaseObject {
+ *     @Configurable(DTO.String())
+ *     protected readonly host: string = 'localhost'
+ * }
+ *
+ * const declaration: LoadObjectOptions = {class: Mailer, host: 'smtp.example.com'}
+ *
+ * const container: Container = new Container()
+ * await container.load([declaration])
+ * const mailer: Mailer = await container.get(Mailer)
+ * ```
+ */
+export declare class LoadObjectOptions<ClassConstructor extends typeof BaseObject = typeof BaseObject> extends DTO {
+    [OBJECT_ID]?: string | symbol;
+    /**
+     * The class of the object, a {@link BaseObject} subclass. Required.
+     */
+    class: ClassConstructor;
+}

package/dist/cjs/options/LoadObjectOptions.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadObjectOptions = exports.OBJECT_ID = void 0;
+const DTO_js_1 = require("../lib/dto/DTO.js");
+const Expect_js_1 = require("../decorators/dto/Expect.js");
+const BaseObject_js_1 = require("../lib/base/BaseObject.js");
+const IndexSignature_js_1 = require("../decorators/dto/IndexSignature.js");
+exports.OBJECT_ID = Symbol('OBJECT_ID');
+/**
+ * The declaration of an object given to `Container.load()` and in the `objects.named` module option: its class and its
+ * options (the keys other than `class`, the values of its `@Configurable` properties).
+ * @example
+ * ```typescript
+ * import {BaseObject, Container, DTO, type LoadObjectOptions} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Mailer extends BaseObject {
+ *     @Configurable(DTO.String())
+ *     protected readonly host: string = 'localhost'
+ * }
+ *
+ * const declaration: LoadObjectOptions = {class: Mailer, host: 'smtp.example.com'}
+ *
+ * const container: Container = new Container()
+ * await container.load([declaration])
+ * const mailer: Mailer = await container.get(Mailer)
+ * ```
+ */
+let LoadObjectOptions = class LoadObjectOptions extends DTO_js_1.DTO {
+    static { _a = exports.OBJECT_ID; }
+};
+exports.LoadObjectOptions = LoadObjectOptions;
+__decorate([
+    (0, Expect_js_1.Expect)(DTO_js_1.DTO.Alternatives(DTO_js_1.DTO.String(), DTO_js_1.DTO.Symbol()).optional()),
+    __metadata("design:type", Object)
+], LoadObjectOptions.prototype, _a, void 0);
+__decorate([
+    (0, Expect_js_1.Expect)(DTO_js_1.DTO.Class(() => BaseObject_js_1.BaseObject).required()),
+    __metadata("design:type", Object)
+], LoadObjectOptions.prototype, "class", void 0);
+exports.LoadObjectOptions = LoadObjectOptions = __decorate([
+    (0, IndexSignature_js_1.IndexSignature)(DTO_js_1.DTO.Any())
+], LoadObjectOptions);

package/dist/cjs/options/ModuleLoadObjectsOptions.d.ts

@@ -0,0 +1,44 @@
+import { DTO } from '../lib/dto/DTO.js';
+import { LoadNamedObjectOptions } from './LoadNamedObjectOptions.js';
+import { LoadAnonymousObjectOptions } from './LoadAnonymousObjectOptions.js';
+import { BaseObject } from '../lib/base/BaseObject.js';
+export type AnonymousObject = LoadAnonymousObjectOptions | typeof BaseObject | string;
+/**
+ * The `objects` module option: the objects a module declares besides its components and providers (plain objects,
+ * modules), named or anonymous.
+ * @example
+ * ```typescript
+ * import {Application, BaseObject, type ModuleLoadObjectsOptions, Module} from 'lakutata'
+ *
+ * class Cart extends BaseObject {
+ * }
+ *
+ * class Catalog extends Module {
+ * }
+ *
+ * const objects: ModuleLoadObjectsOptions = {
+ *     named: {
+ *         catalog: {class: Catalog}
+ *     },
+ *     anonymous: [Cart, './dist/objects/*.js']
+ * }
+ *
+ * Application.run({id: 'shop.app', name: 'Shop', objects: objects})
+ * ```
+ */
+export declare class ModuleLoadObjectsOptions extends DTO {
+    /**
+     * The objects registered under a name (got with `getObject('name')` or `@Inject('name')`): their declarations
+     * (`{class, ...options}`), by name.
+     * @default {}
+     */
+    named?: LoadNamedObjectOptions;
+    /**
+     * The objects registered by their class (got with `getObject(TheClass)` or `@Inject(TheClass)`): classes,
+     * declarations (`{class, ...options}`), or glob patterns of the files to import, relative to the working
+     * directory, each file registering every export which is a {@link BaseObject} subclass (a file failing to import
+     * fails the module's initialization).
+     * @default []
+     */
+    anonymous?: AnonymousObject[];
+}

package/dist/cjs/options/ModuleLoadObjectsOptions.js

@@ -0,0 +1,61 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleLoadObjectsOptions = void 0;
+const DTO_js_1 = require("../lib/dto/DTO.js");
+const Expect_js_1 = require("../decorators/dto/Expect.js");
+const LoadNamedObjectOptions_js_1 = require("./LoadNamedObjectOptions.js");
+const LoadAnonymousObjectOptions_js_1 = require("./LoadAnonymousObjectOptions.js");
+const BaseObject_js_1 = require("../lib/base/BaseObject.js");
+/**
+ * The `objects` module option: the objects a module declares besides its components and providers (plain objects,
+ * modules), named or anonymous.
+ * @example
+ * ```typescript
+ * import {Application, BaseObject, type ModuleLoadObjectsOptions, Module} from 'lakutata'
+ *
+ * class Cart extends BaseObject {
+ * }
+ *
+ * class Catalog extends Module {
+ * }
+ *
+ * const objects: ModuleLoadObjectsOptions = {
+ *     named: {
+ *         catalog: {class: Catalog}
+ *     },
+ *     anonymous: [Cart, './dist/objects/*.js']
+ * }
+ *
+ * Application.run({id: 'shop.app', name: 'Shop', objects: objects})
+ * ```
+ */
+class ModuleLoadObjectsOptions extends DTO_js_1.DTO {
+}
+exports.ModuleLoadObjectsOptions = ModuleLoadObjectsOptions;
+__decorate([
+    (0, Expect_js_1.Expect)(LoadNamedObjectOptions_js_1.LoadNamedObjectOptions.optional().default({})),
+    __metadata("design:type", LoadNamedObjectOptions_js_1.LoadNamedObjectOptions
+    /**
+     * The objects registered by their class (got with `getObject(TheClass)` or `@Inject(TheClass)`): classes,
+     * declarations (`{class, ...options}`), or glob patterns of the files to import, relative to the working
+     * directory, each file registering every export which is a {@link BaseObject} subclass (a file failing to import
+     * fails the module's initialization).
+     * @default []
+     */
+    )
+], ModuleLoadObjectsOptions.prototype, "named", void 0);
+__decorate([
+    (0, Expect_js_1.Expect)(DTO_js_1.DTO.Array(DTO_js_1.DTO.Alternatives(LoadAnonymousObjectOptions_js_1.LoadAnonymousObjectOptions.Schema(), DTO_js_1.DTO.Class(BaseObject_js_1.BaseObject), DTO_js_1.DTO.Glob()))
+        .optional()
+        .default([])),
+    __metadata("design:type", Array)
+], ModuleLoadObjectsOptions.prototype, "anonymous", void 0);

package/dist/cjs/options/ModuleOptions.d.ts

@@ -0,0 +1,74 @@
+import { DTO } from '../lib/dto/DTO.js';
+import { Module } from '../lib/core/Module.js';
+import { ModuleLoadObjectsOptions } from './ModuleLoadObjectsOptions.js';
+import { OverridableNamedObjectOptions } from './OverridableNamedObjectOptions.js';
+import { Component } from '../lib/core/Component.js';
+import { IBaseObjectConstructor } from '../interfaces/IBaseObjectConstructor.js';
+import { Provider } from '../lib/core/Provider.js';
+export type BootstrapAsyncFunction<T = any, U = any> = (target: T) => Promise<U>;
+export type BootstrapOption = string | symbol | IBaseObjectConstructor | BootstrapAsyncFunction<Module, void>;
+/**
+ * The options of a module (and the base of the application options): the components, providers and objects it
+ * declares, and its bootstrap steps. A module gives its own by the initializer of its `options` property; the options
+ * configured for it are merged over them.
+ * @example
+ * ```typescript
+ * import {Component, Module, type ModuleOptions, Provider} from 'lakutata'
+ *
+ * class Inventory extends Component {
+ * }
+ *
+ * class StockQuery extends Provider {
+ * }
+ *
+ * export class StockModule extends Module {
+ *     protected options: ModuleOptions = {
+ *         components: {
+ *             inventory: {class: Inventory, maxListeners: 50}
+ *         },
+ *         providers: {
+ *             stock: {class: StockQuery}
+ *         },
+ *         bootstrap: [
+ *             'inventory',
+ *             async (module: Module): Promise<void> => {
+ *                 await module.getObject('stock')
+ *             }
+ *         ]
+ *     }
+ * }
+ * ```
+ */
+export declare class ModuleOptions extends DTO {
+    /**
+     * The components the module declares, by name: their declarations (`{class, ...options}`), the class a
+     * {@link Component} subclass. A declaration without class completes the options of the component of the same name
+     * declared by the module's initializer or by `Application.preset()`. A class which is not a component fails the
+     * module's initialization with an {@link InvalidObjectTypeException}; a declaration without class and without
+     * component of its name, with an {@link OverridableObjectTargetConfigNotFoundException}.
+     */
+    components?: OverridableNamedObjectOptions<IBaseObjectConstructor<Component>>;
+    /**
+     * The providers the module declares, by name, as the components: the class a {@link Provider} subclass.
+     */
+    providers?: OverridableNamedObjectOptions<IBaseObjectConstructor<Provider>>;
+    /**
+     * The other objects the module declares (plain objects, modules), named or anonymous.
+     * @default {named: {}, anonymous: []}
+     */
+    objects?: ModuleLoadObjectsOptions;
+    /**
+     * The steps run in order once the module's objects are registered: a name, a symbol or a class is got from the
+     * module (creating the object, such as a server starting to listen), an async function is called with the module.
+     * A failing step fails the module's initialization (for the application, a fatal exception).
+     * @default []
+     */
+    bootstrap?: BootstrapOption[];
+    /**
+     * Check the options of the declared objects when the module initializes, before any of them is created: an
+     * invalid value of a configurable property fails the initialization with an
+     * {@link InvalidObjectOptionsException}, an option which is not a configurable property is warned of.
+     * @default true
+     */
+    checkOptions?: boolean;
+}

package/dist/cjs/options/ModuleOptions.js

@@ -0,0 +1,86 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleOptions = void 0;
+const DTO_js_1 = require("../lib/dto/DTO.js");
+const BaseObject_js_1 = require("../lib/base/BaseObject.js");
+const Expect_js_1 = require("../decorators/dto/Expect.js");
+const ModuleLoadObjectsOptions_js_1 = require("./ModuleLoadObjectsOptions.js");
+const OverridableNamedObjectOptions_js_1 = require("./OverridableNamedObjectOptions.js");
+/**
+ * The options of a module (and the base of the application options): the components, providers and objects it
+ * declares, and its bootstrap steps. A module gives its own by the initializer of its `options` property; the options
+ * configured for it are merged over them.
+ * @example
+ * ```typescript
+ * import {Component, Module, type ModuleOptions, Provider} from 'lakutata'
+ *
+ * class Inventory extends Component {
+ * }
+ *
+ * class StockQuery extends Provider {
+ * }
+ *
+ * export class StockModule extends Module {
+ *     protected options: ModuleOptions = {
+ *         components: {
+ *             inventory: {class: Inventory, maxListeners: 50}
+ *         },
+ *         providers: {
+ *             stock: {class: StockQuery}
+ *         },
+ *         bootstrap: [
+ *             'inventory',
+ *             async (module: Module): Promise<void> => {
+ *                 await module.getObject('stock')
+ *             }
+ *         ]
+ *     }
+ * }
+ * ```
+ */
+class ModuleOptions extends DTO_js_1.DTO {
+}
+exports.ModuleOptions = ModuleOptions;
+__decorate([
+    (0, Expect_js_1.Expect)(OverridableNamedObjectOptions_js_1.OverridableNamedObjectOptions.optional()),
+    __metadata("design:type", OverridableNamedObjectOptions_js_1.OverridableNamedObjectOptions)
+], ModuleOptions.prototype, "components", void 0);
+__decorate([
+    (0, Expect_js_1.Expect)(OverridableNamedObjectOptions_js_1.OverridableNamedObjectOptions.optional()),
+    __metadata("design:type", OverridableNamedObjectOptions_js_1.OverridableNamedObjectOptions)
+], ModuleOptions.prototype, "providers", void 0);
+__decorate([
+    (0, Expect_js_1.Expect)(ModuleLoadObjectsOptions_js_1.ModuleLoadObjectsOptions
+        .optional()
+        .default({
+        named: {},
+        anonymous: []
+    })),
+    __metadata("design:type", ModuleLoadObjectsOptions_js_1.ModuleLoadObjectsOptions
+    /**
+     * The steps run in order once the module's objects are registered: a name, a symbol or a class is got from the
+     * module (creating the object, such as a server starting to listen), an async function is called with the module.
+     * A failing step fails the module's initialization (for the application, a fatal exception).
+     * @default []
+     */
+    )
+], ModuleOptions.prototype, "objects", void 0);
+__decorate([
+    (0, Expect_js_1.Expect)(DTO_js_1.DTO.Array(DTO_js_1.DTO.Alternatives(DTO_js_1.DTO.String(), DTO_js_1.DTO.Class(BaseObject_js_1.BaseObject), DTO_js_1.DTO.AsyncFunction()))
+        .optional()
+        .default([])),
+    __metadata("design:type", Array)
+], ModuleOptions.prototype, "bootstrap", void 0);
+__decorate([
+    (0, Expect_js_1.Expect)(DTO_js_1.DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ModuleOptions.prototype, "checkOptions", void 0);

package/dist/cjs/options/OverridableNamedObjectOptions.d.ts

@@ -0,0 +1,26 @@
+import { DTO } from '../lib/dto/DTO.js';
+import { OverridableObjectOptions } from './OverridableObjectOptions.js';
+import { BaseObject } from '../lib/base/BaseObject.js';
+import { IBaseObjectConstructor } from '../interfaces/IBaseObjectConstructor.js';
+/**
+ * The `components` and `providers` module options: each declaration (see {@link OverridableObjectOptions}) under the
+ * name the object is registered under (got with `getObject('name')` or `@Inject('name')`).
+ * @example
+ * ```typescript
+ * import {Application, Component, type IBaseObjectConstructor, type OverridableNamedObjectOptions} from 'lakutata'
+ *
+ * class Mailer extends Component {
+ * }
+ *
+ * const components: OverridableNamedObjectOptions<IBaseObjectConstructor<Component>> = {
+ *     mailer: {class: Mailer},
+ *     //Completes the options of the "log" component preset by the lakutata package
+ *     log: {level: 'debug'}
+ * }
+ *
+ * Application.run({id: 'mail.app', name: 'Mail', components: components})
+ * ```
+ */
+export declare class OverridableNamedObjectOptions<ClassConstructor extends IBaseObjectConstructor<BaseObject> = IBaseObjectConstructor<BaseObject>> extends DTO {
+    [id: string]: OverridableObjectOptions<ClassConstructor>;
+}

package/dist/cjs/options/OverridableNamedObjectOptions.js

@@ -0,0 +1,37 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverridableNamedObjectOptions = void 0;
+const DTO_js_1 = require("../lib/dto/DTO.js");
+const OverridableObjectOptions_js_1 = require("./OverridableObjectOptions.js");
+const IndexSignature_js_1 = require("../decorators/dto/IndexSignature.js");
+/**
+ * The `components` and `providers` module options: each declaration (see {@link OverridableObjectOptions}) under the
+ * name the object is registered under (got with `getObject('name')` or `@Inject('name')`).
+ * @example
+ * ```typescript
+ * import {Application, Component, type IBaseObjectConstructor, type OverridableNamedObjectOptions} from 'lakutata'
+ *
+ * class Mailer extends Component {
+ * }
+ *
+ * const components: OverridableNamedObjectOptions<IBaseObjectConstructor<Component>> = {
+ *     mailer: {class: Mailer},
+ *     //Completes the options of the "log" component preset by the lakutata package
+ *     log: {level: 'debug'}
+ * }
+ *
+ * Application.run({id: 'mail.app', name: 'Mail', components: components})
+ * ```
+ */
+let OverridableNamedObjectOptions = class OverridableNamedObjectOptions extends DTO_js_1.DTO {
+};
+exports.OverridableNamedObjectOptions = OverridableNamedObjectOptions;
+exports.OverridableNamedObjectOptions = OverridableNamedObjectOptions = __decorate([
+    (0, IndexSignature_js_1.IndexSignature)(OverridableObjectOptions_js_1.OverridableObjectOptions.Schema())
+], OverridableNamedObjectOptions);

package/dist/cjs/options/OverridableObjectOptions.d.ts

@@ -0,0 +1,34 @@
+import { DTO } from '../lib/dto/DTO.js';
+import { BaseObject } from '../lib/base/BaseObject.js';
+/**
+ * The declaration of a component or a provider in the module options: its class and its options (the keys other than
+ * `class`, the values of its `@Configurable` properties). Without class, it completes the options of the object of the
+ * same name declared by the module's initializer or by `Application.preset()`: its options override theirs.
+ * @example
+ * ```typescript
+ * import {Component, DTO, Module, type ModuleOptions, type OverridableObjectOptions} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Cache extends Component {
+ *     @Configurable(DTO.Number().integer().min(0))
+ *     protected readonly ttl: number = 60
+ * }
+ *
+ * const declaration: OverridableObjectOptions<typeof Cache> = {class: Cache, ttl: 300}
+ *
+ * export class CacheModule extends Module {
+ *     protected options: ModuleOptions = {
+ *         components: {cache: declaration}
+ *     }
+ * }
+ *
+ * //The cache of this module keeps its entries 10 seconds: its ttl overrides the declared one
+ * export const override: OverridableObjectOptions<typeof Cache> = {ttl: 10}
+ * ```
+ */
+export declare class OverridableObjectOptions<ClassConstructor extends typeof BaseObject = typeof BaseObject> extends DTO {
+    /**
+     * The class of the object; omitted to complete the declaration of the same name.
+     */
+    class?: ClassConstructor;
+}

package/dist/cjs/options/OverridableObjectOptions.js

@@ -0,0 +1,52 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverridableObjectOptions = void 0;
+const DTO_js_1 = require("../lib/dto/DTO.js");
+const BaseObject_js_1 = require("../lib/base/BaseObject.js");
+const Expect_js_1 = require("../decorators/dto/Expect.js");
+const IndexSignature_js_1 = require("../decorators/dto/IndexSignature.js");
+/**
+ * The declaration of a component or a provider in the module options: its class and its options (the keys other than
+ * `class`, the values of its `@Configurable` properties). Without class, it completes the options of the object of the
+ * same name declared by the module's initializer or by `Application.preset()`: its options override theirs.
+ * @example
+ * ```typescript
+ * import {Component, DTO, Module, type ModuleOptions, type OverridableObjectOptions} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Cache extends Component {
+ *     @Configurable(DTO.Number().integer().min(0))
+ *     protected readonly ttl: number = 60
+ * }
+ *
+ * const declaration: OverridableObjectOptions<typeof Cache> = {class: Cache, ttl: 300}
+ *
+ * export class CacheModule extends Module {
+ *     protected options: ModuleOptions = {
+ *         components: {cache: declaration}
+ *     }
+ * }
+ *
+ * //The cache of this module keeps its entries 10 seconds: its ttl overrides the declared one
+ * export const override: OverridableObjectOptions<typeof Cache> = {ttl: 10}
+ * ```
+ */
+let OverridableObjectOptions = class OverridableObjectOptions extends DTO_js_1.DTO {
+};
+exports.OverridableObjectOptions = OverridableObjectOptions;
+__decorate([
+    (0, Expect_js_1.Expect)(DTO_js_1.DTO.Class(() => BaseObject_js_1.BaseObject).optional()),
+    __metadata("design:type", Object)
+], OverridableObjectOptions.prototype, "class", void 0);
+exports.OverridableObjectOptions = OverridableObjectOptions = __decorate([
+    (0, IndexSignature_js_1.IndexSignature)(DTO_js_1.DTO.Any())
+], OverridableObjectOptions);

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/types/ActionPattern.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The pattern identifying an action: an object of key/value pairs (`{cmd: 'user.create'}`), declared by a
+ * `@ServiceAction` (or the action decorator of another channel) and matched against the incoming messages. The type
+ * parameter types its known keys; any other key is allowed.
+ */
+export type ActionPattern<T extends Record<string, any> = {}> = Record<string, any> & T;

package/dist/cjs/types/ActionPattern.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/ApplicationExitReason.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Why the application exits, given to the done handler (onDone)
+ */
+export type ApplicationExitReason = {
+    /**
+     * The exit code of the process
+     */
+    code: number;
+    /**
+     * The signal ending the application (shutdownSignals), none when the application exits by app.exit()
+     */
+    signal?: NodeJS.Signals;
+};