@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/esm/lib/base/EventEmitter.js

@@ -0,0 +1,147 @@
+import { EventEmitter2 } from './internal/EventEmitter2.js';
+/**
+ * The listeners added by on(), once(), many() and their prepended forms are called asynchronously (after the emitting),
+ * their results promised (emitRequest() waits for them); the listeners added by addListener() and onAny() are called
+ * synchronously
+ */
+const onOptions = {
+    async: true,
+    nextTick: false,
+    promisify: true,
+    objectify: false
+};
+export const DefaultEventEmitterOptions = {
+    //The wildcards: "*" for a part of the namespace of an event, "**" for any parts
+    wildcard: true,
+    //The delimiter of the parts of the namespaces
+    delimiter: '.',
+    //No newListener event
+    newListener: false,
+    //No removeListener event
+    removeListener: false,
+    //The number of the listeners of an event above which a possible memory leak is warned of
+    maxListeners: 11,
+    //The event named in the warning of a possible memory leak
+    verboseMemoryLeak: true,
+    //An error event without listener is thrown
+    ignoreErrors: false
+};
+/**
+ * The name given to the emitter: a symbol is a namespace of one part, the wildcard emitter splitting only the strings
+ * @param event
+ */
+function eventName(event) {
+    return typeof event === 'symbol' ? [event] : event;
+}
+export class EventEmitter {
+    constructor(options = {}) {
+        Reflect.defineMetadata(this.constructor.name, new EventEmitter2({ ...DefaultEventEmitterOptions, ...options }), this);
+    }
+    emit(event, ...values) {
+        return Reflect.getMetadata(this.constructor.name, this).emit(eventName(event), ...values);
+    }
+    async emitRequest(event, ...values) {
+        return Reflect.getMetadata(this.constructor.name, this).emitAsync(eventName(event), ...values);
+    }
+    addListener(event, listener) {
+        Reflect.getMetadata(this.constructor.name, this).addListener(eventName(event), listener);
+        return this;
+    }
+    on(event, listener) {
+        Reflect.getMetadata(this.constructor.name, this).on(eventName(event), listener, onOptions);
+        return this;
+    }
+    prependListener(event, listener) {
+        Reflect.getMetadata(this.constructor.name, this).prependListener(eventName(event), listener, onOptions);
+        return this;
+    }
+    once(event, listener) {
+        Reflect.getMetadata(this.constructor.name, this).once(eventName(event), listener, onOptions);
+        return this;
+    }
+    prependOnceListener(event, listener) {
+        Reflect.getMetadata(this.constructor.name, this).prependOnceListener(eventName(event), listener, onOptions);
+        return this;
+    }
+    many(event, timesToListen, listener) {
+        Reflect.getMetadata(this.constructor.name, this).many(eventName(event), timesToListen, listener, onOptions);
+        return this;
+    }
+    prependMany(event, timesToListen, listener) {
+        Reflect.getMetadata(this.constructor.name, this).prependMany(eventName(event), timesToListen, listener, onOptions);
+        return this;
+    }
+    onAny(listener) {
+        Reflect.getMetadata(this.constructor.name, this).onAny(listener);
+        return this;
+    }
+    prependAny(listener) {
+        Reflect.getMetadata(this.constructor.name, this).prependAny(listener);
+        return this;
+    }
+    offAny(listener) {
+        Reflect.getMetadata(this.constructor.name, this).offAny(listener);
+        return this;
+    }
+    removeListener(event, listener) {
+        Reflect.getMetadata(this.constructor.name, this).removeListener(eventName(event), listener);
+        return this;
+    }
+    off(event, listener) {
+        Reflect.getMetadata(this.constructor.name, this).off(eventName(event), listener);
+        return this;
+    }
+    removeAllListeners(event) {
+        Reflect.getMetadata(this.constructor.name, this).removeAllListeners(eventName(event));
+        return this;
+    }
+    setMaxListeners(n) {
+        return Reflect.getMetadata(this.constructor.name, this).setMaxListeners(n);
+    }
+    getMaxListeners() {
+        return Reflect.getMetadata(this.constructor.name, this).getMaxListeners();
+    }
+    eventNames(nsAsArray) {
+        const names = Reflect.getMetadata(this.constructor.name, this).eventNames(nsAsArray);
+        //The symbols given back as they were given, unless the namespaces are asked as arrays
+        return nsAsArray ? names : names.map((name) => Array.isArray(name) && name.length === 1 && typeof name[0] === 'symbol' ? name[0] : name);
+    }
+    listenerCount(event) {
+        //Without an event, the listeners of every event (2.x threw: an event is required with the wildcards)
+        if (event === undefined)
+            return Reflect.getMetadata(this.constructor.name, this).countAllListeners();
+        return Reflect.getMetadata(this.constructor.name, this).listenerCount(eventName(event));
+    }
+    listeners(event) {
+        const emitter = Reflect.getMetadata(this.constructor.name, this);
+        //Without an event, the listeners of every event (the wildcard emitter requires one)
+        if (event === undefined)
+            return emitter.eventNames(true).flatMap((name) => emitter.listeners(name));
+        return emitter.listeners(eventName(event));
+    }
+    listenersAny() {
+        //A copy: changing it does not change the listeners
+        return [...Reflect.getMetadata(this.constructor.name, this).listenersAny()];
+    }
+    hasListeners(event) {
+        const emitter = Reflect.getMetadata(this.constructor.name, this);
+        //Without an event, whether any event has a listener
+        if (event === undefined)
+            return emitter.countAllListeners() > 0;
+        return emitter.hasListeners(eventName(event)).valueOf();
+    }
+}
+/**
+ * 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 class SynchronousEventEmitter extends EventEmitter {
+    on(event, listener) {
+        Reflect.getMetadata(this.constructor.name, this).on(eventName(event), listener);
+        return this;
+    }
+    once(event, listener) {
+        Reflect.getMetadata(this.constructor.name, this).once(eventName(event), listener);
+        return this;
+    }
+}

package/dist/esm/lib/base/async-constructor/Append.js

@@ -0,0 +1,18 @@
+import { isPromiseLike } from '@lakutata/utils/IsPromiseLike';
+export function appendAsyncConstructor(target, asyncConstructor, args) {
+    async function applyAsyncConstructor() {
+        await Promise.resolve();
+        await Reflect.apply(asyncConstructor, target, args !== null && args !== undefined ? args : []);
+        delete target['then'];
+        return target;
+    }
+    if (isPromiseLike(target)) {
+        setThenMethod(target, Promise.resolve(target).then(applyAsyncConstructor));
+    }
+    else {
+        setThenMethod(target, applyAsyncConstructor());
+    }
+}
+function setThenMethod(target, promise) {
+    target.then = promise.then.bind(promise);
+}

package/dist/esm/lib/base/async-constructor/AsyncConstructor.js

@@ -0,0 +1,7 @@
+import { appendAsyncConstructor } from './Append.js';
+export class AsyncConstructor extends Object {
+    constructor(asyncConstructor) {
+        super();
+        appendAsyncConstructor(this, asyncConstructor);
+    }
+}

package/dist/esm/lib/base/internal/ApplicationLaunch.js

@@ -0,0 +1,53 @@
+import { As } from '@lakutata/utils/As';
+/**
+ * The application class, declared by the application module (it cannot be imported here without a cycle)
+ */
+let applicationClass;
+/**
+ * The applications which have launched
+ */
+const launched = new WeakSet();
+/**
+ * The launches waited for, by application
+ */
+const waiting = new WeakMap();
+/**
+ * Declare the application class
+ * @param target
+ */
+export function declareApplicationClass(target) {
+    applicationClass = target;
+}
+/**
+ * Mark an application as launched: every object and the bootstrap of the application are ready
+ * @param application
+ */
+export function markApplicationLaunched(application) {
+    launched.add(application);
+    waiting.get(application)?.resolve();
+    waiting.delete(application);
+}
+/**
+ * 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 function whenApplicationLaunched(object) {
+    let target = object;
+    while (target && !(applicationClass && target instanceof As(applicationClass)))
+        target = target.getParent?.();
+    if (!target)
+        return undefined;
+    if (launched.has(target))
+        return Promise.resolve();
+    let launch = waiting.get(target);
+    if (!launch) {
+        let resolve = () => undefined;
+        const promise = new Promise((resolver) => {
+            resolve = resolver;
+        });
+        launch = { promise: promise, resolve: resolve };
+        waiting.set(target, launch);
+    }
+    return launch.promise;
+}

package/dist/esm/lib/base/internal/ConfigurableRecordsInjection.js

@@ -0,0 +1,76 @@
+import { DI_TARGET_ID } from '../../../constants/DIMetadataKey.js';
+import { constructorSymbol } from '../../ioc/ConstructorSymbol.js';
+import { As } from '@lakutata/utils/As';
+/**
+ * Set configurable records to target constructor with its registration name
+ * @param target
+ * @param registrationName
+ * @param configurableRecords
+ * @constructor
+ */
+export function setConfigurableRecords(target, registrationName, configurableRecords) {
+    if (Reflect.hasOwnMetadata(registrationName, target))
+        Reflect.deleteMetadata(registrationName, target);
+    Reflect.defineMetadata(registrationName, configurableRecords, target);
+}
+/**
+ * Get configurable records from target constructor by its registration name
+ * @param target
+ * @constructor
+ */
+export function getConfigurableRecords(target, registrationName) {
+    const configurableRecords = Reflect.getOwnMetadata(registrationName, target);
+    if (configurableRecords)
+        return configurableRecords;
+    return {};
+}
+/**
+ * Set id to instance
+ * @param target
+ * @param id
+ * @constructor
+ */
+export function setIdToInstance(target, id) {
+    Reflect.defineMetadata(DI_TARGET_ID, id, target);
+}
+/**
+ * Get id from instance
+ * @param target
+ * @constructor
+ */
+export function getIdFromInstance(target) {
+    const id = Reflect.getOwnMetadata(DI_TARGET_ID, target);
+    if (typeof id === 'string')
+        return id;
+    if (constructorSymbol(As(target.constructor)) !== id)
+        return id;
+    return undefined;
+}
+/**
+ * Get the registration name the instance was resolved by (including constructor symbols, unlike GetIdFromInstance)
+ * @param target
+ * @constructor
+ */
+export function getRegistrationNameFromInstance(target) {
+    return Reflect.getOwnMetadata(DI_TARGET_ID, target);
+}
+/**
+ * Set configurable records to instance's metadata
+ * @param target
+ * @param configurableRecords
+ * @constructor
+ */
+export function setConfigurableRecordsToInstance(target, configurableRecords) {
+    Reflect.defineMetadata(target.$uuid, configurableRecords, target);
+}
+/**
+ * Get configurable records from instance's metadata
+ * @param target
+ * @constructor
+ */
+export function getConfigurableRecordsFromInstance(target) {
+    const configurableRecords = Reflect.getOwnMetadata(target.$uuid, target);
+    if (configurableRecords)
+        return configurableRecords;
+    return {};
+}