@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/types/lib/base/BaseObject.d.ts

@@ -0,0 +1,343 @@
+import { AsyncConstructor } from './async-constructor/AsyncConstructor.js';
+import { IBaseObjectConstructor } from '../../interfaces/IBaseObjectConstructor.js';
+import { Module } from '../core/Module.js';
+/**
+ * Internal init function symbol
+ */
+export declare const __init: unique symbol;
+/**
+ * Internal destroy function symbol
+ */
+export declare const __destroy: unique symbol;
+/**
+ * Symbol of the method that makes a destroyed object ready to be initialized again (reload)
+ */
+export declare const __revive: unique symbol;
+/**
+ * Anonymous ID symbol, the default id value if object's id not defined in runtime
+ */
+export declare const anonymousId: symbol;
+/**
+ * The base class of every object managed by the container (the {@link Provider}, {@link Component}, {@link Module} and
+ * {@link Application} classes extend it). Extend it for a plain object; its lifetime is `@Transient`: a new instance
+ * each time it is requested.
+ *
+ * An object is never created with `new`: the container creates it (`getObject()`, `buildObject()`, the module options),
+ * asynchronously: its `@Inject` properties are resolved, its `@Configurable` properties get their configured values
+ * (validated and transformed by their schemas; a property not configured keeps its initializer, else the default of
+ * its schema), then its `init()` runs, then its `startup()` (the object is given to its requesters once started, except
+ * to the call chain of its startup). Once its application has launched, its `launched()` runs. At its teardown
+ * (`dispose()`, or the teardown of the object, scope or application which created it) its `beforeDestroy()` runs, then
+ * the objects it created are destroyed, then its `destroy()` runs. Each object owns a container: the objects it
+ * creates are destroyed with it.
+ * @example
+ * ```typescript
+ * import {BaseObject, Container, DTO} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Counter extends BaseObject {
+ *     @Configurable(DTO.Number().integer().min(0))
+ *     protected readonly start: number = 0
+ *
+ *     #value: number = 0
+ *
+ *     protected async init(): Promise<void> {
+ *         this.#value = this.start
+ *     }
+ *
+ *     public increment(): number {
+ *         return ++this.#value
+ *     }
+ * }
+ *
+ * const container: Container = new Container()
+ * const counter: Counter = await container.build(Counter, {start: 10})
+ * console.log(counter.increment()) //11
+ * await counter.dispose()
+ * ```
+ */
+export declare class BaseObject extends AsyncConstructor {
+    #private;
+    /**
+     * Called by the container only: an object is created through a container (see the class description), never with
+     * `new`.
+     * @param cradleProxy The container's resolution proxy.
+     */
+    constructor(cradleProxy: Record<string | symbol, any>);
+    /**
+     * The name of the class.
+     */
+    static get className(): string;
+    /**
+     * Whether the class accepts an option which is not one of its `@Configurable` properties (an option it reads with
+     * `getConfigurableRecords()`): the modules check the options of the objects they declare and warn of the options
+     * the classes do not accept. Override it in the classes reading options without configurable properties.
+     * @param name The option name.
+     * @param value The option value.
+     * @returns true when the option is accepted; false by default.
+     */
+    static acceptsOption(name: string, value: unknown): boolean;
+    /**
+     * The name of the object's class.
+     */
+    get className(): string;
+    /**
+     * The framework's initializer: injects the dependencies, applies the configured values, runs the hooks, then
+     * `init()`. Override `init()` instead.
+     * @param hooks The steps the framework's subclasses run before `init()`.
+     * @returns Resolves once the object is ready.
+     * @throws {ObjectDestroyedException} When the object has been destroyed (before or during its initialization).
+     * @protected
+     */
+    protected [__init](...hooks: (() => Promise<void>)[]): Promise<void>;
+    /**
+     * Make a destroyed object ready to be initialized again (its reload); its dependencies, destroyed with it, are
+     * injected again. Does nothing when the object is not destroyed.
+     * @throws {ObjectDestroyedException} When the parent's container has been destroyed (or is being destroyed).
+     * @protected
+     */
+    protected [__revive](): void;
+    /**
+     * The framework's destroyer: `beforeDestroy()`, the objects created by this object, the hooks, then `destroy()`;
+     * runs once whatever starts it. Override `beforeDestroy()` and `destroy()` instead.
+     * @param hooks The steps the framework's subclasses run before `destroy()`.
+     * @returns Resolves once the object is destroyed.
+     * @throws {Error} The error of `beforeDestroy()`, a hook or `destroy()` (an `AggregateError` when several fail), to
+     * the first caller only.
+     * @protected
+     */
+    protected [__destroy](...hooks: (() => Promise<void>)[]): Promise<void>;
+    /**
+     * Initialize the object, once its dependencies are injected and its configured values applied; override it. The
+     * object is returned to its requester once it completes; an error thrown here fails the object's creation.
+     * @returns Resolves once initialized.
+     * @protected
+     */
+    protected init(): Promise<void>;
+    /**
+     * Start the object's work once it is initialized and can be got by the other objects (listen on a port, start the
+     * adapters of an entrypoint); override it. The objects getting it (`getObject()`, `@Inject`, a bootstrap step, the
+     * container's `get()` and `set()`) wait until it completes, and fail with its error; but the objects got from
+     * within it, directly or through the objects they create, get the object at once (initialized, not started yet),
+     * so an object it gets may inject it. Its `launched()` runs once it completed (not when it failed); its teardown
+     * waits for it to end. A module's runs once its bootstrap ran (the application's, once it launched). The name of
+     * the hook is `startup` so that the classes having a `start()` method of their own (a container of Docker) are not
+     * started by the framework.
+     * @returns Resolves once the object started.
+     * @protected
+     * @example
+     * ```typescript
+     * import {createServer, type Server} from 'node:http'
+     * import {Component} from 'lakutata'
+     *
+     * export class StatusServer extends Component {
+     *     #server: Server = createServer((_request, response): void => void response.end('ok'))
+     *
+     *     //The objects getting the server get it listening; a port in use fails them
+     *     protected async startup(): Promise<void> {
+     *         await new Promise<void>((resolve, reject): void => {
+     *             this.#server.once('error', reject).listen(8080, resolve)
+     *         })
+     *     }
+     *
+     *     protected async destroy(): Promise<void> {
+     *         await new Promise((resolve): unknown => this.#server.close(resolve))
+     *     }
+     * }
+     * ```
+     */
+    protected startup(): Promise<void>;
+    /**
+     * Called once the object's application has launched (its objects are created and its bootstrap ran), as the
+     * mounted hook of a Vue component: the object starts the work which needs the whole application; override it. An
+     * object created once the application has launched, or without application (in a bare container), is called right
+     * after its initialization; an object destroyed before is not called, a reloaded object is called again. Its errors
+     * are reported through the application's logger, they do not stop the application.
+     * @returns Resolves once the work is started; not awaited by the application.
+     * @protected
+     */
+    protected launched(): Promise<void>;
+    /**
+     * Called when the object's teardown starts, before the objects it created are destroyed (as the parent-first
+     * beforeDestroy of a Vue component): the object stops its work, such as receiving requests, while the objects it
+     * uses are still alive; override it. Called once per teardown, whatever starts it.
+     * @returns Resolves once the work is stopped.
+     * @protected
+     */
+    protected beforeDestroy(): Promise<void>;
+    /**
+     * Release the object's resources (connections, timers…), called once the objects it created are destroyed;
+     * override it. Its error is thrown to the caller of `dispose()`, or reported when a parent's teardown destroys it.
+     * @returns Resolves once released.
+     * @protected
+     */
+    protected destroy(): Promise<void>;
+    /**
+     * Get an object registered by its class, from this object's container or its parents (the module's registrations,
+     * the application's), as {@link Container.get}. The objects it creates are destroyed with this object.
+     * @param constructor The class the object was registered with (or an `@Autoload` class).
+     * @param configurableRecords The options of the object (the values of its `@Configurable` properties and the options
+     * it reads), merged over the ones it was registered with. Ignored, with a warning outside production, when the
+     * cached singleton or scoped instance already exists; a scoped object requested with options is a new instance
+     * owned by this object.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When this object has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     * @protected
+     */
+    protected getObject<T extends BaseObject>(constructor: IBaseObjectConstructor<T>, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * Get an object registered under a name (its key in the module options), as {@link BaseObject.getObject} by class.
+     * @param name The registration name.
+     * @param configurableRecords The options of the object (the values of its `@Configurable` properties and the options
+     * it reads), merged over the ones it was registered with. Ignored, with a warning outside production, when the
+     * cached singleton or scoped instance already exists; a scoped object requested with options is a new instance
+     * owned by this object.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When this object has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     * @protected
+     */
+    protected getObject<T extends BaseObject>(name: string, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * Get an object registered under a symbol, as {@link BaseObject.getObject} by class.
+     * @param name The registration symbol.
+     * @param configurableRecords The options of the object (the values of its `@Configurable` properties and the options
+     * it reads), merged over the ones it was registered with. Ignored, with a warning outside production, when the
+     * cached singleton or scoped instance already exists; a scoped object requested with options is a new instance
+     * owned by this object.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When this object has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     * @protected
+     */
+    protected getObject<T extends BaseObject>(name: symbol, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * Get an object registered under a name or a symbol, as {@link BaseObject.getObject} by class.
+     * @param name The registration name or symbol.
+     * @param configurableRecords The options of the object (the values of its `@Configurable` properties and the options
+     * it reads), merged over the ones it was registered with. Ignored, with a warning outside production, when the
+     * cached singleton or scoped instance already exists; a scoped object requested with options is a new instance
+     * owned by this object.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When this object has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     * @protected
+     */
+    protected getObject<T extends BaseObject>(name: string | symbol, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * Get an object registered under a name, a symbol or by its class, as {@link BaseObject.getObject} by class.
+     * @param nameOrConstructor The registration name, symbol or class.
+     * @param configurableRecords The options of the object (the values of its `@Configurable` properties and the options
+     * it reads), merged over the ones it was registered with. Ignored, with a warning outside production, when the
+     * cached singleton or scoped instance already exists; a scoped object requested with options is a new instance
+     * owned by this object.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When this object has been destroyed.
+     * @throws {Error} When nothing is registered under it, or the object fails to be created.
+     * @protected
+     */
+    protected getObject<T extends BaseObject>(nameOrConstructor: string | symbol | IBaseObjectConstructor<T>, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * Create a new object of a class without registering it, whatever its lifetime, as {@link Container.build}; it is
+     * destroyed with this object (unless disposed before).
+     * @param constructor The class, registered or not.
+     * @param configurableRecords The options of the object.
+     * @returns The new object, once created and initialized.
+     * @throws {ObjectDestroyedException} When this object has been destroyed.
+     * @throws {Error} When the object fails to be created.
+     * @protected
+     */
+    protected buildObject<T extends BaseObject>(constructor: IBaseObjectConstructor<T>, configurableRecords?: Record<string, any>): Promise<T>;
+    /**
+     * The options the object was created with, as they were given: the values of its configurable properties before
+     * their validation, and the options which are not configurable properties.
+     * @returns A copy of the options.
+     * @protected
+     */
+    protected getConfigurableRecords(): Record<string, any>;
+    /**
+     * The object which created this object (the module or component whose container created it).
+     * @returns The parent, or undefined for an object created by a container without owner (the root container).
+     * @protected
+     */
+    protected getParent(): BaseObject | undefined;
+    /**
+     * The nearest module among the object's parents (its module, or the application).
+     * @returns The module; undefined (despite the type) for an object created outside any module.
+     * @protected
+     */
+    protected getModule(): Module;
+    /**
+     * A random UUID identifying the instance.
+     */
+    get $uuid(): string;
+    /**
+     * The name the object was registered under (its key in the module options), or a symbol of its class for an object
+     * registered by its class or built without registration.
+     */
+    get $id(): string | symbol;
+    /**
+     * A symbol unique to the instance (made from its `$uuid`), created on first read.
+     */
+    get $symbol(): symbol;
+    /**
+     * Set a property of the object; the value is not validated, even for a `@Configurable` property.
+     * @param propertyKey The property name.
+     * @param value The value.
+     */
+    setProperty(propertyKey: string, value: any): void;
+    /**
+     * Read an own property of the object.
+     * @param propertyKey The property name.
+     * @param defaultValue The value returned when the object has no own property of this name.
+     * @returns The property value, or the default value.
+     */
+    getProperty<T = any>(propertyKey: string, defaultValue?: T): T;
+    /**
+     * Whether the object has an own property (not a method or accessor of its class) of this name or symbol.
+     * @param propertyKey The property name or symbol.
+     * @returns true when the property exists.
+     */
+    hasProperty(propertyKey: string | symbol): boolean;
+    /**
+     * The symbols of the object's own properties.
+     * @returns The symbols.
+     */
+    propertySymbols(): symbol[];
+    /**
+     * The names of the object's own properties (not its class's methods and accessors).
+     * @returns The names.
+     */
+    propertyNames(): string[];
+    /**
+     * Whether the object has a method of this name or symbol (a function of its class, not an own property).
+     * @param name The method name or symbol.
+     * @returns true when the method exists.
+     */
+    hasMethod(name: string | symbol): boolean;
+    /**
+     * Get a method bound to the object, to call it by name.
+     * @param name The method name or symbol.
+     * @param throwExceptionIfNotFound Throw when the method does not exist, instead of returning a function doing
+     * nothing; false by default.
+     * @returns The bound method, or a function doing nothing (returning undefined) when it does not exist.
+     * @throws {MethodNotFoundException} When the method does not exist and `throwExceptionIfNotFound` is true.
+     */
+    getMethod(name: string | symbol, throwExceptionIfNotFound?: boolean): (...args: any[]) => any | Promise<any>;
+    /**
+     * Destroy the object: its `beforeDestroy()`, the objects it created, then its `destroy()`. Calling it more than once
+     * destroys once. A disposed singleton or scoped object is dropped from its container, which creates a new one on
+     * the next request. Using a destroyed object (`getObject()`, `buildObject()`) throws an
+     * {@link ObjectDestroyedException}.
+     * @returns Resolves once the object is destroyed.
+     * @throws {Error} The error of the object's own `beforeDestroy()` or `destroy()` (an `AggregateError` when several
+     * fail); the errors of the objects it created are reported through the application's logger instead.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Dispose the object at the end of an `await using` block, as {@link BaseObject.dispose}.
+     * @returns Resolves once the object is destroyed.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/types/lib/base/EventEmitter.d.ts

@@ -0,0 +1,37 @@
+import { type ConstructorOptions, type EventAndListener, type ListenerFn, type event, type OnOptions } from './internal/EventEmitter2.js';
+export type { event, ListenerFn, EventAndListener, OnOptions };
+export type TEventEmitterOptions = ConstructorOptions;
+export declare const DefaultEventEmitterOptions: TEventEmitterOptions;
+export declare class EventEmitter {
+    constructor(options?: TEventEmitterOptions);
+    emit(event: string | symbol | event[], ...values: any[]): boolean;
+    emitRequest(event: string | symbol | event[], ...values: any[]): Promise<any[]>;
+    addListener(event: string | symbol | event[], listener: ListenerFn): this;
+    on(event: string | symbol | event[], listener: ListenerFn): this;
+    prependListener(event: string | symbol | event[], listener: ListenerFn): this;
+    once(event: string | symbol | event[], listener: ListenerFn): this;
+    prependOnceListener(event: string | symbol | event[], listener: ListenerFn): this;
+    many(event: string | symbol | event[], timesToListen: number, listener: ListenerFn): this;
+    prependMany(event: string | symbol | event[], timesToListen: number, listener: ListenerFn): this;
+    onAny(listener: EventAndListener): this;
+    prependAny(listener: EventAndListener): this;
+    offAny(listener: ListenerFn): this;
+    removeListener(event: string | symbol | event[], listener: ListenerFn): this;
+    off(event: string | symbol | event[], listener: ListenerFn): this;
+    removeAllListeners(event?: string | symbol | event[] | undefined): this;
+    setMaxListeners(n: number): void;
+    getMaxListeners(): number;
+    eventNames(nsAsArray?: boolean | undefined): (string | symbol | event[])[];
+    listenerCount(event?: string | symbol | event[] | undefined): number;
+    listeners(event?: string | symbol | event[] | undefined): ListenerFn[];
+    listenersAny(): ListenerFn[];
+    hasListeners(event?: string | symbol | event[] | undefined): boolean;
+}
+/**
+ * An emitter calling the listeners added by on() and once() when the event is emitted (the lifecycle of the
+ * application: its handlers run before the objects acting once it launched)
+ */
+export declare class SynchronousEventEmitter extends EventEmitter {
+    on(event: string | symbol | event[], listener: ListenerFn): this;
+    once(event: string | symbol | event[], listener: ListenerFn): this;
+}

package/dist/types/lib/base/async-constructor/Append.d.ts

@@ -0,0 +1 @@
+export declare function appendAsyncConstructor<T, U extends any[]>(target: T, asyncConstructor: (...args: U) => PromiseLike<void>, args?: U): void;

package/dist/types/lib/base/async-constructor/AsyncConstructor.d.ts

@@ -0,0 +1,3 @@
+export declare class AsyncConstructor extends Object {
+    constructor(asyncConstructor: () => PromiseLike<void>);
+}

package/dist/types/lib/base/internal/ApplicationLaunch.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Declare the application class
+ * @param target
+ */
+export declare function declareApplicationClass(target: Function): void;
+/**
+ * Mark an application as launched: every object and the bootstrap of the application are ready
+ * @param application
+ */
+export declare function markApplicationLaunched(application: object): void;
+/**
+ * Wait until the application an object belongs to has launched
+ * @param object
+ * @return undefined when the object does not belong to an application (such as the objects of a bare container)
+ */
+export declare function whenApplicationLaunched(object: object): Promise<void> | undefined;

package/dist/types/lib/base/internal/ConfigurableRecordsInjection.d.ts

@@ -0,0 +1,47 @@
+import { BaseObject } from '../BaseObject.js';
+/**
+ * Set configurable records to target constructor with its registration name
+ * @param target
+ * @param registrationName
+ * @param configurableRecords
+ * @constructor
+ */
+export declare function setConfigurableRecords<ClassConstructor extends typeof BaseObject>(target: ClassConstructor, registrationName: string | symbol, configurableRecords: Record<string, any>): void;
+/**
+ * Get configurable records from target constructor by its registration name
+ * @param target
+ * @constructor
+ */
+export declare function getConfigurableRecords<ClassConstructor extends typeof BaseObject>(target: ClassConstructor, registrationName: string | symbol): Record<string, any>;
+/**
+ * Set id to instance
+ * @param target
+ * @param id
+ * @constructor
+ */
+export declare function setIdToInstance<ClassInstance extends BaseObject>(target: ClassInstance, id: string | symbol): void;
+/**
+ * Get id from instance
+ * @param target
+ * @constructor
+ */
+export declare function getIdFromInstance<ClassInstance extends BaseObject>(target: ClassInstance): string | symbol | undefined;
+/**
+ * Get the registration name the instance was resolved by (including constructor symbols, unlike GetIdFromInstance)
+ * @param target
+ * @constructor
+ */
+export declare function getRegistrationNameFromInstance<ClassInstance extends BaseObject>(target: ClassInstance): string | symbol | undefined;
+/**
+ * Set configurable records to instance's metadata
+ * @param target
+ * @param configurableRecords
+ * @constructor
+ */
+export declare function setConfigurableRecordsToInstance<ClassInstance extends BaseObject>(target: ClassInstance, configurableRecords: Record<string, any>): void;
+/**
+ * Get configurable records from instance's metadata
+ * @param target
+ * @constructor
+ */
+export declare function getConfigurableRecordsFromInstance<ClassInstance extends BaseObject>(target: ClassInstance): Record<string, any>;

package/dist/types/lib/base/internal/EventEmitter2.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Derived from lib/eventemitter2.js of eventemitter2 6.4.9 (MIT, see THIRD_PARTY_NOTICES.md): the event emitter of
+ * 2.x, with its wildcards (the parts of the namespaces of the events separated by the delimiter, "*" for a part and
+ * "**" for any parts). The API the framework uses is ported (listenTo, waitFor and the cancelable promises are not).
+ * The nodes of the listener tree have no prototype (an event named like a property of Object.prototype, such as
+ * "constructor", used the property in the upstream), and a listener both promisified and called in the next tick is
+ * called (the upstream only resolved its promise)
+ */
+export type event = string | symbol;
+export type eventNS = string | event[];
+export type ListenerFn = (...values: any[]) => any;
+export type EventAndListener = (event: string | string[], ...values: any[]) => any;
+export interface ConstructorOptions {
+    /**
+     * Use the wildcards
+     */
+    wildcard?: boolean;
+    /**
+     * The delimiter of the parts of the namespaces
+     */
+    delimiter?: string;
+    /**
+     * Emit the newListener event
+     */
+    newListener?: boolean;
+    /**
+     * Emit the removeListener event
+     */
+    removeListener?: boolean;
+    /**
+     * The number of the listeners of an event above which a possible memory leak is warned of
+     */
+    maxListeners?: number;
+    /**
+     * Name the event in the warning of a possible memory leak
+     */
+    verboseMemoryLeak?: boolean;
+    /**
+     * Do not throw an error event without listener
+     */
+    ignoreErrors?: boolean;
+}
+export interface OnOptions {
+    /**
+     * Call the listener asynchronously (setImmediate)
+     */
+    async?: boolean;
+    /**
+     * Call the listener in the next tick (process.nextTick)
+     */
+    nextTick?: boolean;
+    /**
+     * Make the asynchronous listener return a promise of its result
+     */
+    promisify?: boolean;
+    /**
+     * Not supported: the emitter is returned
+     */
+    objectify?: boolean;
+}
+/**
+ * A listener: a function, with the original function of its wrappers
+ */
+type Listener = ListenerFn & {
+    _origin?: ListenerFn;
+    _async?: boolean;
+    listener?: ListenerFn;
+};
+/**
+ * The listeners of an event: one function, or several (warned of a possible memory leak once)
+ */
+type Listeners = Listener | (Listener[] & {
+    warned?: boolean;
+});
+/**
+ * A node of the listener tree: its listeners, and its children by part
+ */
+type TreeNode = {
+    _listeners?: Listeners | null;
+    [part: string | symbol]: any;
+};
+export declare class EventEmitter2 {
+    /**
+     * The number of the listeners of an event above which a possible memory leak is warned of, for the emitters not
+     * given one (10; 0 for no warning)
+     */
+    static get defaultMaxListeners(): number;
+    static set defaultMaxListeners(n: number);
+    delimiter: string;
+    /**
+     * The event of the listener being called
+     */
+    event: string | event[];
+    protected wildcard?: boolean;
+    protected verboseMemoryLeak: boolean;
+    protected ignoreErrors?: boolean;
+    protected listenerTree?: TreeNode;
+    protected _events?: Record<string | symbol, Listeners | null>;
+    protected _all?: EventAndListener[];
+    protected _conf?: ConstructorOptions;
+    protected _maxListeners?: number;
+    protected _newListener: boolean;
+    protected _removeListener: boolean;
+    constructor(conf?: ConstructorOptions);
+    protected init(): void;
+    protected configure(conf?: ConstructorOptions): void;
+    protected logPossibleMemoryLeak(count: number, eventName: string | symbol): void;
+    /**
+     * The parts of an event
+     * @param type
+     */
+    protected split(type: any): any[];
+    /**
+     * Collect the listeners of the tree matching an event (with the wildcards of the event and of the tree), and the
+     * nodes holding them
+     * @param handlers
+     * @param type
+     * @param tree
+     * @param i
+     * @param typeLength
+     */
+    protected searchListenerTree(handlers: Listener[] | null, type: any, tree: TreeNode | undefined, i: number, typeLength?: number): TreeNode[] | null;
+    protected growListenerTree(type: any, listener: Listener, prepend: boolean): boolean | undefined;
+    /**
+     * The events having listeners in a tree (the branches of a node having listeners count as events too, as upstream)
+     * @param tree
+     * @param events
+     * @param root
+     * @param asArray
+     */
+    protected collectTreeEvents(tree: TreeNode, events: any[], root: any[] | null, asArray?: boolean): any[];
+    /**
+     * Remove the branches without listeners: whether the node has a branch or listeners
+     * @param root
+     */
+    protected recursivelyGarbageCollect(root: TreeNode): boolean | undefined;
+    /**
+     * The listener calling a listener asynchronously
+     * @param listener
+     * @param options
+     */
+    protected setupListener(listener: Listener, options: OnOptions | boolean): Listener;
+    setMaxListeners(n: number): void;
+    getMaxListeners(): number;
+    once(event: event | eventNS, fn: ListenerFn, options?: OnOptions | boolean): this;
+    prependOnceListener(event: event | eventNS, fn: ListenerFn, options?: OnOptions | boolean): this;
+    many(event: event | eventNS, ttl: number, fn: ListenerFn, options?: OnOptions | boolean): this;
+    prependMany(event: event | eventNS, ttl: number, fn: ListenerFn, options?: OnOptions | boolean): this;
+    protected _many(event: event | eventNS, ttl: number, fn: ListenerFn, prepend: boolean, options?: OnOptions | boolean): this;
+    /**
+     * The event of the emitting and of the listeners: the parts of a namespace joined, unless one is a symbol
+     * @param type
+     */
+    protected eventOf(type: any): any;
+    emit(type: event | eventNS, ...values: any[]): boolean;
+    emitAsync(type: event | eventNS, ...values: any[]): Promise<any[]> | false;
+    on(type: event | eventNS, listener: ListenerFn, options?: OnOptions | boolean): this;
+    prependListener(type: event | eventNS, listener: ListenerFn, options?: OnOptions | boolean): this;
+    addListener(type: event | eventNS, listener: ListenerFn, options?: OnOptions | boolean): this;
+    onAny(fn: EventAndListener): this;
+    prependAny(fn: EventAndListener): this;
+    protected _onAny(fn: EventAndListener, prepend: boolean): this;
+    protected _on(type: event | eventNS | EventAndListener, listener: ListenerFn, prepend: boolean, options?: OnOptions | boolean): this;
+    /**
+     * Whether a listener is the one given or one of its wrappers
+     * @param handler
+     * @param listener
+     */
+    protected isListener(handler: Listener, listener: ListenerFn): boolean;
+    off(type: event | eventNS, listener: ListenerFn): this;
+    removeListener(type: event | eventNS, listener: ListenerFn): this;
+    offAny(fn?: ListenerFn): this;
+    removeAllListeners(type?: event | eventNS): this;
+    listeners(type?: event | eventNS): ListenerFn[];
+    eventNames(nsAsArray?: boolean): (event | eventNS)[];
+    listenerCount(type?: event | eventNS): number;
+    hasListeners(type?: string | String): boolean;
+    listenersAny(): EventAndListener[];
+    /**
+     * Not in the upstream: the number of the listeners of every event (the listeners of any event excluded)
+     */
+    countAllListeners(): number;
+}
+export {};

package/dist/types/lib/base/internal/MemberDeclarations.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The declaration of a property removed by a class: a subclass declaring the property otherwise (an injection
+ * declared again as a configurable property, or a configurable property declared again as an injection)
+ */
+export declare const REMOVED: unique symbol;
+/**
+ * The declarations of the properties of a class only, and the declarations of its parents it removes
+ */
+type OwnDeclarations<Declaration> = Map<string | symbol, Declaration | typeof REMOVED>;
+/**
+ * The declarations of the properties of a class only (created when missing)
+ * @param metadataKey
+ * @param target
+ */
+export declare function ownDeclarations<Declaration>(metadataKey: string | symbol, target: Function): OwnDeclarations<Declaration>;
+/**
+ * The declarations of the properties of a class and of its parents: from the farthest parent to the class, the closest
+ * declaration of a property wins, a removal by a closer class removes it
+ * @param metadataKey
+ * @param target
+ */
+export declare function mergedDeclarations<Declaration>(metadataKey: string | symbol, target: Function): Map<string | symbol, Declaration>;
+export {};