@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/cjs/types/ApplicationExitReason.js

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

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

@@ -0,0 +1,6 @@
+import { IConstructor } from '../interfaces/IConstructor.js';
+/**
+ * A class decorator typed by the class it decorates: it receives the constructor, and returns it, a replacement, or
+ * nothing.
+ */
+export type ClassDecorator<Constructor extends IConstructor> = (target: Constructor) => Constructor | void;

package/dist/cjs/types/ClassDecorator.js

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

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

@@ -0,0 +1,20 @@
+import { Component } from '../lib/core/Component.js';
+/**
+ * The declaration of a component in the module options: its class, and its options under any other key.
+ */
+export interface BaseComponentOptions {
+    /**
+     * The class of the component, a {@link Component} subclass.
+     */
+    class: typeof Component;
+    [prop: string]: any;
+}
+/**
+ * The declaration of a component whose options are typed: the options `T` with the class.
+ */
+export type ComponentOptions<T> = T & BaseComponentOptions;
+/**
+ * A function building the declaration of a component from its typed options, adding its class (the packages export
+ * such builders for their components).
+ */
+export type ComponentOptionsBuilder<T> = (options: T) => ComponentOptions<T>;

package/dist/cjs/types/ComponentOptions.js

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

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

@@ -0,0 +1,25 @@
+/**
+ * The options of the validation of the cron expressions (DTO.Cron())
+ */
+export type CronOptions = {
+    /**
+     * Allow the names of the months and of the days of the week (JAN, MON-FRI)
+     */
+    alias?: boolean;
+    /**
+     * Allow a field of the seconds (six fields)
+     */
+    seconds?: boolean;
+    /**
+     * Allow "?" in the fields of the day of the month and of the day of the week
+     */
+    allowBlankDay?: boolean;
+    /**
+     * Allow 7 as Sunday in the field of the day of the week
+     */
+    allowSevenAsSunday?: boolean;
+    /**
+     * Allow the nth day of the week of the month in the field of the day of the week (1#2: the second Monday)
+     */
+    allowNthWeekdayOfMonth?: boolean;
+};

package/dist/cjs/types/CronOptions.js

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

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

@@ -0,0 +1,284 @@
+/**
+ * The type names of JSON Schema
+ */
+export type JSONSchemaTypeName = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+/**
+ * A subschema: a schema, or a boolean schema (true accepts every value, false none)
+ */
+export type JSONSchemaDefinition = JSONSchema | boolean;
+/**
+ * A JSON Schema (drafts 04 to 2020-12), or an OpenAPI 3.0/3.1 schema object (the schemas of the property maps are
+ * objects: a boolean schema can be written as {} or {not: {}}). Returned by `toJsonSchema()` and `DTO.toJsonSchema()`,
+ * accepted by `fromJsonSchema()` and `DTO.fromJsonSchema()`. The keywords not listed (the extensions, `x-...`) are
+ * allowed as well.
+ */
+export interface JSONSchema {
+    /**
+     * The URI of the JSON Schema version (dialect) the schema is written in, like
+     * `https://json-schema.org/draft/2020-12/schema`.
+     */
+    $schema?: string;
+    /**
+     * The URI identifying the schema, which the references (`$ref`) of other schemas can point to (drafts 06 and
+     * later).
+     */
+    $id?: string;
+    /**
+     * The URI identifying the schema in draft 04 (replaced by `$id` in the later drafts).
+     */
+    id?: string;
+    /**
+     * A reference to another schema, by URI or JSON pointer (`#/$defs/User`), which the value must match too.
+     */
+    $ref?: string;
+    /**
+     * A plain name identifying the schema in its document, which a reference reaches as `#name` (draft 2019-09 and
+     * later).
+     */
+    $anchor?: string;
+    /**
+     * A reference resolved in the dynamic scope of the validation, to the `$dynamicAnchor` of the same name
+     * (draft 2020-12).
+     */
+    $dynamicRef?: string;
+    /**
+     * A name which the `$dynamicRef` references resolve to dynamically (draft 2020-12).
+     */
+    $dynamicAnchor?: string;
+    /**
+     * A reference resolved in the dynamic scope of the validation, to the schemas marked with `$recursiveAnchor`
+     * (draft 2019-09).
+     */
+    $recursiveRef?: string;
+    /**
+     * Whether the schema is a target of the `$recursiveRef` references (draft 2019-09).
+     */
+    $recursiveAnchor?: boolean;
+    /**
+     * A comment for the schema maintainers, ignored by the validation.
+     */
+    $comment?: string;
+    /**
+     * The reusable schemas, by name, which the references reach as `#/$defs/<name>` (draft 2019-09 and later).
+     */
+    $defs?: Record<string, JSONSchema>;
+    /**
+     * The reusable schemas, by name, which the references reach as `#/definitions/<name>` (drafts 04 to 07).
+     */
+    definitions?: Record<string, JSONSchema>;
+    /**
+     * The type of the value, or the types it may have.
+     */
+    type?: JSONSchemaTypeName | JSONSchemaTypeName[];
+    /**
+     * The only values allowed.
+     */
+    enum?: unknown[];
+    /**
+     * The only value allowed.
+     */
+    const?: unknown;
+    /**
+     * The number a numeric value must be a multiple of (greater than 0).
+     */
+    multipleOf?: number;
+    /**
+     * The largest numeric value allowed (inclusive).
+     */
+    maximum?: number;
+    /**
+     * The limit a numeric value must be lower than (a number from draft 06), or in draft 04 and OpenAPI 3.0 whether
+     * `maximum` is exclusive (a boolean).
+     */
+    exclusiveMaximum?: number | boolean;
+    /**
+     * The smallest numeric value allowed (inclusive).
+     */
+    minimum?: number;
+    /**
+     * The limit a numeric value must be greater than (a number from draft 06), or in draft 04 and OpenAPI 3.0 whether
+     * `minimum` is exclusive (a boolean).
+     */
+    exclusiveMinimum?: number | boolean;
+    /**
+     * The maximum length of a string value, in characters (Unicode code points).
+     */
+    maxLength?: number;
+    /**
+     * The minimum length of a string value, in characters (Unicode code points).
+     */
+    minLength?: number;
+    /**
+     * The regular expression (ECMA 262) a string value must match, anywhere in the string unless anchored.
+     */
+    pattern?: string;
+    /**
+     * The format of a string value: `date-time`, `email`, `uri`, `uuid`, `ipv4`…
+     */
+    format?: string;
+    /**
+     * The encoding of the content of a string value, like `base64`.
+     */
+    contentEncoding?: string;
+    /**
+     * The media type of the content of a string value, like `application/json`.
+     */
+    contentMediaType?: string;
+    /**
+     * The schema of every item of an array value; an array of schemas lists the schemas of the first items (drafts 04
+     * to 2019-09, replaced by `prefixItems` in draft 2020-12).
+     */
+    items?: JSONSchemaDefinition | JSONSchemaDefinition[];
+    /**
+     * The schemas of the first items of an array value, in order (draft 2020-12).
+     */
+    prefixItems?: JSONSchemaDefinition[];
+    /**
+     * The schema of the items following the ones `items` lists as an array (drafts 04 to 2019-09).
+     */
+    additionalItems?: JSONSchemaDefinition;
+    /**
+     * The schema of the array items no other keyword evaluated (draft 2019-09 and later).
+     */
+    unevaluatedItems?: JSONSchemaDefinition;
+    /**
+     * A schema at least one item of an array value must match (`minContains` and `maxContains` change the count).
+     */
+    contains?: JSONSchemaDefinition;
+    /**
+     * The minimum number of items matching `contains` (draft 2019-09 and later).
+     * @default 1
+     */
+    minContains?: number;
+    /**
+     * The maximum number of items matching `contains` (draft 2019-09 and later).
+     */
+    maxContains?: number;
+    /**
+     * The maximum number of items of an array value.
+     */
+    maxItems?: number;
+    /**
+     * The minimum number of items of an array value.
+     */
+    minItems?: number;
+    /**
+     * Whether the items of an array value must all be different.
+     * @default false
+     */
+    uniqueItems?: boolean;
+    /**
+     * The schemas of the properties of an object value, by property name.
+     */
+    properties?: Record<string, JSONSchema>;
+    /**
+     * The schemas of the properties whose name matches a regular expression, by regular expression.
+     */
+    patternProperties?: Record<string, JSONSchema>;
+    /**
+     * The schema of the properties neither `properties` nor `patternProperties` list; false forbids them.
+     */
+    additionalProperties?: JSONSchemaDefinition;
+    /**
+     * The schema of the properties no other keyword evaluated (draft 2019-09 and later).
+     */
+    unevaluatedProperties?: JSONSchemaDefinition;
+    /**
+     * The schema every property name of an object value must match.
+     */
+    propertyNames?: JSONSchemaDefinition;
+    /**
+     * The names of the properties an object value must have.
+     */
+    required?: string[];
+    /**
+     * The maximum number of properties of an object value.
+     */
+    maxProperties?: number;
+    /**
+     * The minimum number of properties of an object value.
+     */
+    minProperties?: number;
+    /**
+     * By property name: when the property is present, the properties listed must be too, or the object must match
+     * the schema (drafts 04 to 07, split into `dependentRequired` and `dependentSchemas` in draft 2019-09).
+     */
+    dependencies?: Record<string, JSONSchema | string[]>;
+    /**
+     * By property name: the properties an object value must have when it has that property (draft 2019-09 and later).
+     */
+    dependentRequired?: Record<string, string[]>;
+    /**
+     * By property name: the schema an object value must match when it has that property (draft 2019-09 and later).
+     */
+    dependentSchemas?: Record<string, JSONSchema>;
+    /**
+     * The schemas the value must all match.
+     */
+    allOf?: JSONSchemaDefinition[];
+    /**
+     * The schemas the value must match at least one of.
+     */
+    anyOf?: JSONSchemaDefinition[];
+    /**
+     * The schemas the value must match exactly one of.
+     */
+    oneOf?: JSONSchemaDefinition[];
+    /**
+     * A schema the value must not match.
+     */
+    not?: JSONSchemaDefinition;
+    /**
+     * A condition: a value matching it must match `then`, the others `else` (draft 07 and later).
+     */
+    if?: JSONSchemaDefinition;
+    /**
+     * The schema a value matching `if` must match.
+     */
+    then?: JSONSchemaDefinition;
+    /**
+     * The schema a value not matching `if` must match.
+     */
+    else?: JSONSchemaDefinition;
+    /**
+     * A short title of the value, for documentation.
+     */
+    title?: string;
+    /**
+     * A description of the value, for documentation.
+     */
+    description?: string;
+    /**
+     * The value used when it is missing (a schema imported by `fromJsonSchema()` applies it).
+     */
+    default?: unknown;
+    /**
+     * Example values, for documentation.
+     */
+    examples?: unknown[];
+    /**
+     * Whether the value should not be used any more (draft 2019-09 and later, OpenAPI).
+     * @default false
+     */
+    deprecated?: boolean;
+    /**
+     * Whether the value is managed by its owner and is ignored when sent to it.
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * Whether the value is only sent to its owner and never returned by it (a password).
+     * @default false
+     */
+    writeOnly?: boolean;
+    /**
+     * Whether the value may be null as well as of its `type` (OpenAPI 3.0; the later versions add `null` to `type`).
+     * @default false
+     */
+    nullable?: boolean;
+    /**
+     * An example value, for documentation (OpenAPI).
+     */
+    example?: unknown;
+    [keyword: string]: unknown;
+}

package/dist/cjs/types/JSONSchema.js

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

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

@@ -0,0 +1,5 @@
+/**
+ * A method decorator typed by the class prototype and the method it decorates: it receives the prototype, the method
+ * name and its property descriptor, and returns the descriptor to use, or nothing to keep it.
+ */
+export type MethodDecorator<ClassPrototype, Method, Property = string | symbol> = (target: ClassPrototype, propertyKey: Property, descriptor: TypedPropertyDescriptor<Method>) => TypedPropertyDescriptor<Method> | void;

package/dist/cjs/types/MethodDecorator.js

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

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

@@ -0,0 +1,20 @@
+import { Module } from '../lib/core/Module.js';
+/**
+ * The declaration of a module in the module options: its class, and its options under any other key.
+ */
+export interface BaseModuleOptions {
+    /**
+     * The class of the module, a {@link Module} subclass.
+     */
+    class: typeof Module;
+    [prop: string]: any;
+}
+/**
+ * The declaration of a module whose options are typed: the options `T` with the class.
+ */
+export type ModuleOptions<T> = T & BaseModuleOptions;
+/**
+ * A function building the declaration of a module from its typed options, adding its class (the packages export
+ * such builders for their modules).
+ */
+export type ModuleOptionsBuilder<T> = (options: T) => ModuleOptions<T>;

package/dist/cjs/types/ModuleOptions.js

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

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

@@ -0,0 +1,20 @@
+import { BaseObject } from '../lib/base/BaseObject.js';
+/**
+ * The declaration of an object in the module options: its class, and its options under any other key.
+ */
+export interface BaseObjectOptions {
+    /**
+     * The class of the object, an {@link BaseObject} subclass.
+     */
+    class: typeof BaseObject;
+    [prop: string]: any;
+}
+/**
+ * The declaration of an object whose options are typed: the options `T` with the class.
+ */
+export type ObjectOptions<T> = T & BaseObjectOptions;
+/**
+ * A function building the declaration of an object from its typed options, adding its class (the packages export
+ * such builders for their objects).
+ */
+export type ObjectOptionsBuilder<T> = (options: T) => ObjectOptions<T>;

package/dist/cjs/types/ObjectOptions.js

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

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

@@ -0,0 +1,21 @@
+/**
+ * The pagination of a result (PaginationResultDTO)
+ */
+export type PaginationMeta = {
+    /**
+     * The number of the items of the page
+     */
+    count: number;
+    /**
+     * The number of the items of all the pages
+     */
+    total: number;
+    /**
+     * The maximum number of the items of a page
+     */
+    limit: number;
+    /**
+     * The number of the items before the page
+     */
+    offset: number;
+};

package/dist/cjs/types/PaginationMeta.js

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

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

@@ -0,0 +1,5 @@
+/**
+ * A parameter decorator typed by the class prototype it decorates: it receives the prototype, the method name and the
+ * position of the parameter (from 0).
+ */
+export type ParameterDecorator<ClassPrototype> = (target: ClassPrototype, propertyKey: string | symbol, parameterIndex: number) => void;

package/dist/cjs/types/ParameterDecorator.js

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

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

@@ -0,0 +1,4 @@
+/**
+ * A property decorator typed by the class prototype it decorates: it receives the prototype and the property name.
+ */
+export type PropertyDecorator<ClassPrototype> = (target: ClassPrototype, propertyKey: string | symbol) => void;

package/dist/cjs/types/PropertyDecorator.js

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

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

@@ -0,0 +1,20 @@
+import { Provider } from '../lib/core/Provider.js';
+/**
+ * The declaration of a provider in the module options: its class, and its options under any other key.
+ */
+export interface BaseProviderOptions {
+    /**
+     * The class of the provider, a {@link Provider} subclass.
+     */
+    class: typeof Provider;
+    [prop: string]: any;
+}
+/**
+ * The declaration of a provider whose options are typed: the options `T` with the class.
+ */
+export type ProviderOptions<T> = T & BaseProviderOptions;
+/**
+ * A function building the declaration of a provider from its typed options, adding its class (the packages export
+ * such builders for their providers).
+ */
+export type ProviderOptionsBuilder<T> = (options: T) => ProviderOptions<T>;

package/dist/cjs/types/ProviderOptions.js

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

package/dist/esm/components/ConsoleLogger.js

@@ -0,0 +1,96 @@
+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);
+};
+import { formatWithOptions } from 'node:util';
+import { Component } from '../lib/core/Component.js';
+import { Singleton } from '../decorators/di/Lifetime.js';
+import { Configurable } from '../decorators/di/Configurable.js';
+import { DTO } from '../lib/dto/DTO.js';
+import { getAppName } from '../lib/foundation/BasicInfo.js';
+const LEVELS = { trace: 10, debug: 20, info: 30, warn: 40, error: 50, silent: Infinity };
+/**
+ * The logger of a core-only application, writing plain lines to the console:
+ * `[<ISO time>] <LEVEL> (<application name>): <message>`, formatted as `util.format()` (an object given before its
+ * message is written after it); the warnings and errors to stderr, the other levels to stdout. The application uses it
+ * when it has no `log` component; register it as `log` to configure its level. The `lakutata` package replaces it with
+ * its Logger component.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {ConsoleLogger} from '@lakutata/core/com/logger'
+ *
+ * Application.run({
+ *     id: 'tool.app',
+ *     name: 'Tool',
+ *     components: {
+ *         log: {class: ConsoleLogger, level: 'debug'}
+ *     }
+ * }).onLaunched((app, logger): void => logger.debug({pid: process.pid}, 'Launched'))
+ * ```
+ */
+let ConsoleLogger = class ConsoleLogger extends Component {
+    /**
+     * Write a log line, unless its level is below the configured one.
+     * @param level The level of the line (`trace`, `debug`, `info`, `warn`, `error`).
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     * @protected
+     */
+    write(level, args) {
+        if (LEVELS[level] < LEVELS[this.level])
+            return;
+        const [first, ...rest] = args;
+        //An object comes before its message, as in the structured loggers
+        const parts = typeof first === 'object' && first !== null && typeof rest[0] === 'string' ? [...rest, first] : args;
+        const line = `[${new Date().toISOString()}] ${level.toUpperCase()} (${getAppName()}): ${formatWithOptions({ colors: false }, ...parts)}\n`;
+        LEVELS[level] >= LEVELS.warn ? process.stderr.write(line) : process.stdout.write(line);
+    }
+    /**
+     * Log an error to stderr.
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    error(...args) {
+        this.write('error', args);
+    }
+    /**
+     * Log a warning to stderr.
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    warn(...args) {
+        this.write('warn', args);
+    }
+    /**
+     * Log an information to stdout.
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    info(...args) {
+        this.write('info', args);
+    }
+    /**
+     * Log a debugging detail to stdout (written when the level is `debug` or `trace`).
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    debug(...args) {
+        this.write('debug', args);
+    }
+    /**
+     * Log a tracing detail to stdout (written when the level is `trace`).
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    trace(...args) {
+        this.write('trace', args);
+    }
+};
+__decorate([
+    Configurable(DTO.String().valid(...Object.keys(LEVELS)).optional().default('info')),
+    __metadata("design:type", String)
+], ConsoleLogger.prototype, "level", void 0);
+ConsoleLogger = __decorate([
+    Singleton()
+], ConsoleLogger);
+export { ConsoleLogger };

package/dist/esm/constants/DIMetadataKey.js

@@ -0,0 +1,10 @@
+import 'reflect-metadata';
+export const DI_CONTAINER_INJECT_PROPERTIES = Symbol('LAKUTATA.DI.CONTAINER.INJECT.PROPERTIES');
+export const DI_TARGET_CONSTRUCTOR_LIFETIME = Symbol('LAKUTATA.DI.TARGET.CONSTRUCTOR.LIFETIME');
+export const DI_TARGET_CONSTRUCTOR_LIFETIME_LOCK = Symbol('LAKUTATA.DI.TARGET.CONSTRUCTOR.LIFETIME.LOCK');
+export const DI_TARGET_CONSTRUCTOR_INJECTS = Symbol('LAKUTATA.DI.TARGET.CONSTRUCTOR.INJECTS');
+export const DI_TARGET_CONSTRUCTOR_CONFIGURABLE_PROPERTIES = Symbol('LAKUTATA.DI.TARGET.CONSTRUCTOR.CONFIGURABLE.PROPERTIES');
+export const DI_TARGET_CONSTRUCTOR_SYMBOL = Symbol('LAKUTATA.DI.TARGET.CONSTRUCTOR.SYMBOL');
+export const DI_TARGET_CONSTRUCTOR_AUTOLOAD = Symbol('LAKUTATA.DI.TARGET.CONSTRUCTOR.AUTOLOAD');
+export const DI_TARGET_CONTAINER = Symbol('LAKUTATA.DI.TARGET.CONTAINER');
+export const DI_TARGET_ID = Symbol('LAKUTATA.DI.TARGET.ID');

package/dist/esm/constants/DTOMetadataKey.js

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+export const DTO_CONSTRUCTOR = Symbol('LAKUTATA.DTO.CONSTRUCTOR');
+export const DTO_INDEX_SIGNATURE_SCHEMA = Symbol('LAKUTATA.DTO.INDEX.SIGNATURE.SCHEMA');
+export const DTO_PROPERTY_SCHEMAS = Symbol('LAKUTATA.DTO.PROPERTY.SCHEMAS');
+export const DTO_OBJECT_REFINEMENT = Symbol('LAKUTATA.DTO.OBJECT.REFINEMENT');

package/dist/esm/decorators/asst/After.js

@@ -0,0 +1,30 @@
+import { registerAfterFunction } from '../../lib/base/internal/MethodAssistantFunction.js';
+/**
+ * Run a function after each call of the decorated method, with its result. The function is called with the instance as
+ * `this`; a value it returns other than `undefined` replaces the result, `undefined` keeps it. Several `@After` on a
+ * method run in turn, each one receiving the result left by the previous one; an error thrown by the function is thrown
+ * by the call.
+ * @param afterFunc The function receiving the method's result (awaited when the method is async), and returning a
+ * value of the method's return type (a promise for an async method). It may be async only when the method is async.
+ * @returns The method decorator.
+ * @throws {InvalidAssistantFunctionTypeException} When the class is defined, if `afterFunc` is async and the method is
+ * not, or if the decorated member is not a method.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {After} from 'lakutata/decorator/asst'
+ *
+ * class Prices extends Component {
+ *     //The prices are rounded to cents, whatever their computation
+ *     @After(async function (this: Prices, price: number): Promise<number> {
+ *         return Math.round(price * 100) / 100
+ *     })
+ *     public async withTax(price: number): Promise<number> {
+ *         return price * 1.196
+ *     }
+ * }
+ * ```
+ */
+export function After(afterFunc) {
+    return (target, propertyKey, descriptor) => registerAfterFunction(target, propertyKey, descriptor, afterFunc);
+}