@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/cjs/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 {};

package/dist/cjs/lib/base/internal/MemberDeclarations.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOVED = void 0;
+exports.ownDeclarations = ownDeclarations;
+exports.mergedDeclarations = mergedDeclarations;
+const ObjectParentConstructors_1 = require("@lakutata/utils/ObjectParentConstructors");
+/**
+ * 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)
+ */
+exports.REMOVED = Symbol('REMOVED');
+/**
+ * The declarations of the properties of a class only (created when missing)
+ * @param metadataKey
+ * @param target
+ */
+function ownDeclarations(metadataKey, target) {
+    let declarations = Reflect.getOwnMetadata(metadataKey, target);
+    if (!declarations) {
+        declarations = new Map();
+        Reflect.defineMetadata(metadataKey, declarations, target);
+    }
+    return declarations;
+}
+/**
+ * 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
+ */
+function mergedDeclarations(metadataKey, target) {
+    const merged = new Map();
+    for (const constructor of [...(0, ObjectParentConstructors_1.objectParentConstructors)(target).reverse(), target]) {
+        const own = Reflect.getOwnMetadata(metadataKey, constructor);
+        own?.forEach((declaration, propertyKey) => {
+            if (declaration === exports.REMOVED) {
+                merged.delete(propertyKey);
+            }
+            else {
+                merged.set(propertyKey, declaration);
+            }
+        });
+    }
+    return merged;
+}

package/dist/cjs/lib/base/internal/MethodAssistantFunction.d.ts

@@ -0,0 +1,20 @@
+export type BeforeFunction<ClassPrototype extends Object, Method extends (...args: any[]) => unknown> = (this: ClassPrototype, ...args: Parameters<Method>) => Promise<Parameters<Method> | void> | Parameters<Method> | void;
+export type AfterFunction<ClassPrototype extends Object, Method extends (...args: any[]) => unknown> = (this: ClassPrototype, result: Awaited<ReturnType<Method>>) => Promise<ReturnType<Method> | void> | ReturnType<Method> | void;
+/**
+ * Register a function which will run before target method
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param beforeFunction
+ * @constructor
+ */
+export declare function registerBeforeFunction<ClassPrototype extends Object, Method extends (...args: any[]) => unknown>(target: ClassPrototype, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<Method>, beforeFunction: BeforeFunction<ClassPrototype, Method>): TypedPropertyDescriptor<Method>;
+/**
+ * Register a function which will run after target method
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param afterFunction
+ * @constructor
+ */
+export declare function registerAfterFunction<ClassPrototype extends Object, Method extends (...args: any[]) => unknown>(target: ClassPrototype, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<Method>, afterFunction: AfterFunction<ClassPrototype, Method>): TypedPropertyDescriptor<Method>;

package/dist/cjs/lib/base/internal/MethodAssistantFunction.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBeforeFunction = registerBeforeFunction;
+exports.registerAfterFunction = registerAfterFunction;
+const types_1 = require("node:util/types");
+const InvalidAssistantFunctionTypeException_js_1 = require("../../../exceptions/InvalidAssistantFunctionTypeException.js");
+const As_1 = require("@lakutata/utils/As");
+const ASST_BEFORE_FUNC_SET = Symbol('ASST.BEFORE.FUNC.SET');
+const ASST_AFTER_FUNC_SET = Symbol('ASST.AFTER.FUNC.SET');
+const ASST_MODIFIED = Symbol('ASST.MODIFIED');
+/**
+ * Register a function which will run before target method
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param beforeFunction
+ * @constructor
+ */
+function registerBeforeFunction(target, propertyKey, descriptor, beforeFunction) {
+    descriptor.value = registerAssistantFunctionToMethod(target, propertyKey, applicabilityCheck(descriptor.value, beforeFunction), {
+        before: beforeFunction
+    });
+    return descriptor;
+}
+/**
+ * Register a function which will run after target method
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param afterFunction
+ * @constructor
+ */
+function registerAfterFunction(target, propertyKey, descriptor, afterFunction) {
+    descriptor.value = registerAssistantFunctionToMethod(target, propertyKey, applicabilityCheck(descriptor.value, afterFunction), {
+        after: afterFunction
+    });
+    return descriptor;
+}
+/**
+ * Register assistant function to method
+ * @param target
+ * @param propertyKey
+ * @param originalMethod
+ * @param assistantFunction
+ */
+function registerAssistantFunctionToMethod(target, propertyKey, originalMethod, assistantFunction) {
+    const beforeFunctionSet = Reflect.getOwnMetadata(ASST_BEFORE_FUNC_SET, target, propertyKey) || new Set();
+    const afterFunctionSet = Reflect.getOwnMetadata(ASST_AFTER_FUNC_SET, target, propertyKey) || new Set();
+    if (assistantFunction.before) {
+        beforeFunctionSet.add(assistantFunction.before);
+        Reflect.defineMetadata(ASST_BEFORE_FUNC_SET, beforeFunctionSet, target, propertyKey);
+    }
+    if (assistantFunction.after) {
+        afterFunctionSet.add(assistantFunction.after);
+        Reflect.defineMetadata(ASST_AFTER_FUNC_SET, afterFunctionSet, target, propertyKey);
+    }
+    if (Reflect.hasOwnMetadata(ASST_MODIFIED, target, propertyKey))
+        return (0, As_1.As)(originalMethod);
+    Reflect.defineMetadata(ASST_MODIFIED, true, target, propertyKey);
+    let modifiedMethod;
+    if ((0, types_1.isAsyncFunction)(originalMethod)) {
+        modifiedMethod = async function (...args) {
+            const beforeFunctionSet = Reflect.getOwnMetadata(ASST_BEFORE_FUNC_SET, target, propertyKey) || new Set();
+            const afterFunctionSet = Reflect.getOwnMetadata(ASST_AFTER_FUNC_SET, target, propertyKey) || new Set();
+            for (const beforeFunc of beforeFunctionSet) {
+                const beforeFuncResult = await beforeFunc.call(this, ...args);
+                if (beforeFuncResult !== undefined)
+                    args = beforeFuncResult;
+            }
+            let result = await originalMethod.call(this, ...args);
+            for (const afterFunc of afterFunctionSet) {
+                const afterFuncResult = await afterFunc.call(this, result);
+                if (afterFuncResult !== undefined)
+                    result = afterFuncResult;
+            }
+            return result;
+        };
+    }
+    else {
+        modifiedMethod = function (...args) {
+            const beforeFunctionSet = Reflect.getOwnMetadata(ASST_BEFORE_FUNC_SET, target, propertyKey) || new Set();
+            const afterFunctionSet = Reflect.getOwnMetadata(ASST_AFTER_FUNC_SET, target, propertyKey) || new Set();
+            for (const beforeFunc of beforeFunctionSet) {
+                const beforeFuncResult = (0, As_1.As)(beforeFunc.call(this, ...args));
+                if (beforeFuncResult !== undefined)
+                    args = beforeFuncResult;
+            }
+            let result = originalMethod.call(this, ...args);
+            for (const afterFunc of afterFunctionSet) {
+                const afterFuncResult = (0, As_1.As)(afterFunc.call(this, result));
+                if (afterFuncResult !== undefined)
+                    result = afterFuncResult;
+            }
+            return result;
+        };
+    }
+    return modifiedMethod;
+}
+/**
+ * Whether assistant function applicable to target method
+ */
+function applicabilityCheck(targetMethod, assistantFunction) {
+    if (!targetMethod)
+        throw new InvalidAssistantFunctionTypeException_js_1.InvalidAssistantFunctionTypeException('Target method is undefined');
+    if ((0, types_1.isAsyncFunction)(targetMethod))
+        return targetMethod;
+    if (!(0, types_1.isAsyncFunction)(assistantFunction))
+        return targetMethod;
+    throw new InvalidAssistantFunctionTypeException_js_1.InvalidAssistantFunctionTypeException('Assistant function must not be async function when target method is not async function');
+}

package/dist/cjs/lib/base/internal/ModuleConfigLoader.d.ts

@@ -0,0 +1,46 @@
+import { BootstrapOption, type ModuleOptions } from '../../../options/ModuleOptions.js';
+import { LoadObjectOptions } from '../../../options/LoadObjectOptions.js';
+import { Module } from '../../core/Module.js';
+import { BaseObject } from '../BaseObject.js';
+import { OverridableNamedObjectOptions } from '../../../options/OverridableNamedObjectOptions.js';
+import { ObjectType } from './ObjectType.js';
+import { IBaseObjectConstructor } from '../../../interfaces/IBaseObjectConstructor.js';
+/**
+ * Module configurations loader
+ */
+export declare class ModuleConfigLoader {
+    protected readonly $module: Module;
+    protected readonly $presetLoadOptionsSet: Set<LoadObjectOptions | typeof BaseObject | string>;
+    protected readonly $loadOptions: (LoadObjectOptions | typeof BaseObject | string)[];
+    protected readonly $bootstrap: BootstrapOption[];
+    /**
+     * Constructor
+     * @param module
+     * @param moduleOptions
+     * @param presetLoadOptions
+     */
+    constructor(module: Module, moduleOptions: ModuleOptions, presetLoadOptions?: (LoadObjectOptions | typeof BaseObject | string)[]);
+    /**
+     * Validate constructor's object type
+     * @param expectObjectType
+     * @param target
+     * @param id
+     * @protected
+     */
+    protected validateObjectType<ClassConstructor extends IBaseObjectConstructor>(expectObjectType: ObjectType, target: ClassConstructor, id?: string): ClassConstructor;
+    /**
+     * Process overridable named object options
+     * @param objectType
+     * @param options
+     * @protected
+     */
+    protected processOverridableNamedObjectOptions(objectType: ObjectType, options?: OverridableNamedObjectOptions): void;
+    /**
+     * Load options for container.load()
+     */
+    get loadOptions(): (LoadObjectOptions | typeof BaseObject | string)[];
+    /**
+     * Load bootstrap for module
+     */
+    get bootstrap(): BootstrapOption[];
+}

package/dist/cjs/lib/base/internal/ModuleConfigLoader.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleConfigLoader = void 0;
+const LoadObjectOptions_js_1 = require("../../../options/LoadObjectOptions.js");
+const BaseObject_js_1 = require("../BaseObject.js");
+const OverridableObjectTargetConfigNotFoundException_js_1 = require("../../../exceptions/di/OverridableObjectTargetConfigNotFoundException.js");
+const As_1 = require("@lakutata/utils/As");
+const ObjectType_js_1 = require("./ObjectType.js");
+const InvalidObjectTypeException_js_1 = require("../../../exceptions/InvalidObjectTypeException.js");
+const ArrayToSet_1 = require("@lakutata/utils/ArrayToSet");
+const SetToArray_1 = require("@lakutata/utils/SetToArray");
+/**
+ * Module configurations loader
+ */
+class ModuleConfigLoader {
+    /**
+     * Constructor
+     * @param module
+     * @param moduleOptions
+     * @param presetLoadOptions
+     */
+    constructor(module, moduleOptions, presetLoadOptions = []) {
+        this.$presetLoadOptionsSet = new Set();
+        this.$loadOptions = [];
+        this.$bootstrap = [];
+        this.$module = module;
+        this.$presetLoadOptionsSet = (0, ArrayToSet_1.arrayToSet)(presetLoadOptions);
+        this.$bootstrap = moduleOptions.bootstrap ? moduleOptions.bootstrap : [];
+        //Process anonymous objects
+        moduleOptions.objects?.anonymous?.forEach((anonymousObject) => this.$loadOptions.push(anonymousObject));
+        //Process named objects
+        if (moduleOptions.objects && moduleOptions.objects.named) {
+            const namedObjects = moduleOptions.objects.named;
+            Object.keys(namedObjects).forEach((id) => this.$loadOptions.push({
+                ...namedObjects[id],
+                [LoadObjectOptions_js_1.OBJECT_ID]: id
+            }));
+        }
+        //Process component objects
+        this.processOverridableNamedObjectOptions(ObjectType_js_1.ObjectType.Component, moduleOptions.components);
+        //Process provider objects
+        this.processOverridableNamedObjectOptions(ObjectType_js_1.ObjectType.Provider, moduleOptions.providers);
+    }
+    /**
+     * Validate constructor's object type
+     * @param expectObjectType
+     * @param target
+     * @param id
+     * @protected
+     */
+    validateObjectType(expectObjectType, target, id) {
+        const objectType = (0, ObjectType_js_1.getObjectType)(target);
+        if (objectType === expectObjectType)
+            return target;
+        //The objects declared in the wrong configuration name the configuration they belong to
+        const expected = expectObjectType.toLowerCase();
+        const actual = objectType.toLowerCase();
+        const hint = objectType === ObjectType_js_1.ObjectType.Component || objectType === ObjectType_js_1.ObjectType.Provider
+            ? `, declare it in the ${actual}s configuration`
+            //The modules are objects: objects: {named: {<id>: {class: <Module>}}}
+            : objectType === ObjectType_js_1.ObjectType.Module ? ', declare it in the objects configuration (objects.named)' : '';
+        throw new InvalidObjectTypeException_js_1.InvalidObjectTypeException('{0} configuration only accepts object declarations of {1} types: "{2}" ({3}) is a {4}{5}', [expectObjectType, expected, id ?? target.name, target.name, actual, hint]);
+    }
+    /**
+     * Process overridable named object options
+     * @param objectType
+     * @param options
+     * @protected
+     */
+    processOverridableNamedObjectOptions(objectType, options) {
+        if (!options)
+            return;
+        Object.keys(options).forEach((id) => {
+            const overridableObjectOptions = options[id];
+            overridableObjectOptions[LoadObjectOptions_js_1.OBJECT_ID] = id;
+            if (overridableObjectOptions.class) {
+                overridableObjectOptions.class = this.validateObjectType(objectType, overridableObjectOptions.class, id);
+                //An object declared with its class replaces the preset object of the same name
+                for (const loadOptions of this.$presetLoadOptionsSet) {
+                    if (typeof loadOptions === 'string' || loadOptions instanceof BaseObject_js_1.BaseObject)
+                        continue;
+                    if (id === loadOptions[LoadObjectOptions_js_1.OBJECT_ID])
+                        this.$presetLoadOptionsSet.delete(loadOptions);
+                }
+                return this.$loadOptions.push((0, As_1.As)(overridableObjectOptions)) ? void (0) : void (0);
+            }
+            for (const loadOptions of this.$presetLoadOptionsSet) {
+                if (typeof loadOptions === 'string')
+                    continue;
+                if (loadOptions instanceof BaseObject_js_1.BaseObject)
+                    continue;
+                if (overridableObjectOptions[LoadObjectOptions_js_1.OBJECT_ID] === loadOptions[LoadObjectOptions_js_1.OBJECT_ID]) {
+                    this.$loadOptions.push(Object.assign({}, loadOptions, overridableObjectOptions));
+                    return this.$presetLoadOptionsSet.delete(loadOptions) ? void (0) : void (0);
+                }
+            }
+            throw new OverridableObjectTargetConfigNotFoundException_js_1.OverridableObjectTargetConfigNotFoundException('No applicable configuration target found');
+        });
+    }
+    /**
+     * Load options for container.load()
+     */
+    get loadOptions() {
+        return [...this.$loadOptions, ...(0, SetToArray_1.setToArray)(this.$presetLoadOptionsSet)];
+    }
+    /**
+     * Load bootstrap for module
+     */
+    get bootstrap() {
+        return this.$bootstrap;
+    }
+}
+exports.ModuleConfigLoader = ModuleConfigLoader;

package/dist/cjs/lib/base/internal/ModuleInitialization.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The method of a module giving its initialization (its objects loaded, its bootstrap run): the container resolving the
+ * module for an object outside it waits for it
+ */
+export declare const MODULE_INITIALIZATION: symbol;

package/dist/cjs/lib/base/internal/ModuleInitialization.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_INITIALIZATION = void 0;
+/**
+ * The method of a module giving its initialization (its objects loaded, its bootstrap run): the container resolving the
+ * module for an object outside it waits for it
+ */
+exports.MODULE_INITIALIZATION = Symbol('LAKUTATA.MODULE.INITIALIZATION');

package/dist/cjs/lib/base/internal/ObjectConfiguration.d.ts

@@ -0,0 +1,29 @@
+import { BaseObject } from '../BaseObject.js';
+import { Schema } from '../../validation/types/Schema.js';
+export type ObjectConfigurablePropertyMap<DataType = any> = Map<string | symbol, {
+    schema: Schema<DataType>;
+    fn: (value: DataType) => DataType | Promise<DataType>;
+}>;
+/**
+ * Add object configurable property to Set
+ * @param target
+ * @param propertyKey
+ * @param schema
+ * @param fn
+ * @constructor
+ */
+export declare function setObjectConfigurableProperty<ClassPrototype extends BaseObject, DataType>(target: ClassPrototype, propertyKey: string | symbol, schema?: Schema<DataType>, fn?: (value: DataType) => DataType | Promise<DataType>): void;
+/**
+ * Remove the configurable property of the parents of a class: the class declares the property otherwise
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+export declare function removeObjectConfigurableProperty<ClassPrototype extends BaseObject>(target: ClassPrototype, propertyKey: string | symbol): void;
+/**
+ * Get object configurable properties by its prototype: the ones of the class and of its parents, the closest
+ * declaration of a property winning
+ * @param target
+ * @constructor
+ */
+export declare function getObjectConfigurableProperties<ClassPrototype extends BaseObject>(target: ClassPrototype): ObjectConfigurablePropertyMap;

package/dist/cjs/lib/base/internal/ObjectConfiguration.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setObjectConfigurableProperty = setObjectConfigurableProperty;
+exports.removeObjectConfigurableProperty = removeObjectConfigurableProperty;
+exports.getObjectConfigurableProperties = getObjectConfigurableProperties;
+const DIMetadataKey_js_1 = require("../../../constants/DIMetadataKey.js");
+const DTO_js_1 = require("../../dto/DTO.js");
+const ObjectConstructor_1 = require("@lakutata/utils/ObjectConstructor");
+const MemberDeclarations_js_1 = require("./MemberDeclarations.js");
+/**
+ * Add object configurable property to Set
+ * @param target
+ * @param propertyKey
+ * @param schema
+ * @param fn
+ * @constructor
+ */
+function setObjectConfigurableProperty(target, propertyKey, schema = DTO_js_1.DTO.Any(), fn) {
+    (0, MemberDeclarations_js_1.ownDeclarations)(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_CONFIGURABLE_PROPERTIES, (0, ObjectConstructor_1.objectConstructor)(target)).set(propertyKey, {
+        schema: schema,
+        fn: fn ? fn : (value) => value
+    });
+}
+/**
+ * Remove the configurable property of the parents of a class: the class declares the property otherwise
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+function removeObjectConfigurableProperty(target, propertyKey) {
+    (0, MemberDeclarations_js_1.ownDeclarations)(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_CONFIGURABLE_PROPERTIES, (0, ObjectConstructor_1.objectConstructor)(target)).set(propertyKey, MemberDeclarations_js_1.REMOVED);
+}
+/**
+ * Get object configurable properties by its prototype: the ones of the class and of its parents, the closest
+ * declaration of a property winning
+ * @param target
+ * @constructor
+ */
+function getObjectConfigurableProperties(target) {
+    return (0, MemberDeclarations_js_1.mergedDeclarations)(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_CONFIGURABLE_PROPERTIES, (0, ObjectConstructor_1.objectConstructor)(target));
+}

package/dist/cjs/lib/base/internal/ObjectContainer.d.ts

@@ -0,0 +1,15 @@
+import { Container } from '../../core/Container.js';
+import { BaseObject } from '../BaseObject.js';
+/**
+ * Set container getter
+ * @param target
+ * @param container
+ * @constructor
+ */
+export declare function setObjectContainerGetter<ClassPrototype extends BaseObject>(target: ClassPrototype, container: Container): void;
+/**
+ * Get container via class prototype
+ * @param target
+ * @constructor
+ */
+export declare function getObjectContainer<ClassPrototype extends BaseObject>(target: ClassPrototype): Container;

package/dist/cjs/lib/base/internal/ObjectContainer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setObjectContainerGetter = setObjectContainerGetter;
+exports.getObjectContainer = getObjectContainer;
+const DIMetadataKey_js_1 = require("../../../constants/DIMetadataKey.js");
+/**
+ * Set container getter
+ * @param target
+ * @param container
+ * @constructor
+ */
+function setObjectContainerGetter(target, container) {
+    Reflect.defineMetadata(DIMetadataKey_js_1.DI_TARGET_CONTAINER, () => container, target);
+}
+/**
+ * Get container via class prototype
+ * @param target
+ * @constructor
+ */
+function getObjectContainer(target) {
+    const containerGetter = Reflect.getOwnMetadata(DIMetadataKey_js_1.DI_TARGET_CONTAINER, target);
+    return containerGetter();
+}

package/dist/cjs/lib/base/internal/ObjectInjection.d.ts

@@ -0,0 +1,43 @@
+import { BaseObject } from '../BaseObject.js';
+import { IBaseObjectConstructor } from '../../../interfaces/IBaseObjectConstructor.js';
+export type InjectionName = string | symbol | IBaseObjectConstructor<BaseObject>;
+export type InjectionTransformFunction = (injection: any) => any | Promise<any>;
+export type ObjectInjectionMap = Map<string | symbol, {
+    name: string | symbol | Function;
+    transform: InjectionTransformFunction;
+}>;
+/**
+ * Set object inject item
+ * @param target
+ * @param propertyKey
+ * @param name
+ * @param transform
+ * @constructor
+ */
+export declare function setObjectInjectItem<ClassPrototype extends BaseObject>(target: ClassPrototype, propertyKey: string | symbol, name: string | symbol | Function, transform: InjectionTransformFunction): void;
+/**
+ * Remove the injection of a property of the parents of a class: the class declares the property otherwise
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+export declare function removeObjectInjectItem<ClassPrototype extends BaseObject>(target: ClassPrototype, propertyKey: string | symbol): void;
+/**
+ * Get object inject items by its prototype: the ones of the class and of its parents, the closest declaration of a
+ * property winning
+ * @param target
+ * @constructor
+ */
+export declare function getObjectInjectItemsByPrototype<ClassPrototype extends BaseObject>(target: ClassPrototype): ObjectInjectionMap;
+/**
+ * Mark object as autoload
+ * @param target
+ * @constructor
+ */
+export declare function markObjectAsAutoload<ClassConstructor extends typeof BaseObject>(target: ClassConstructor): ClassConstructor;
+/**
+ * Whether an object is autoload object or not
+ * @param target
+ * @constructor
+ */
+export declare function getObjectIsAutoload<ClassConstructor extends typeof BaseObject>(target: ClassConstructor): boolean;

package/dist/cjs/lib/base/internal/ObjectInjection.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setObjectInjectItem = setObjectInjectItem;
+exports.removeObjectInjectItem = removeObjectInjectItem;
+exports.getObjectInjectItemsByPrototype = getObjectInjectItemsByPrototype;
+exports.markObjectAsAutoload = markObjectAsAutoload;
+exports.getObjectIsAutoload = getObjectIsAutoload;
+const DIMetadataKey_js_1 = require("../../../constants/DIMetadataKey.js");
+const ObjectConstructor_1 = require("@lakutata/utils/ObjectConstructor");
+const MemberDeclarations_js_1 = require("./MemberDeclarations.js");
+/**
+ * Set object inject item
+ * @param target
+ * @param propertyKey
+ * @param name
+ * @param transform
+ * @constructor
+ */
+function setObjectInjectItem(target, propertyKey, name, transform) {
+    (0, MemberDeclarations_js_1.ownDeclarations)(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_INJECTS, (0, ObjectConstructor_1.objectConstructor)(target)).set(propertyKey, {
+        name: name,
+        transform: transform
+    });
+}
+/**
+ * Remove the injection of a property of the parents of a class: the class declares the property otherwise
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+function removeObjectInjectItem(target, propertyKey) {
+    (0, MemberDeclarations_js_1.ownDeclarations)(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_INJECTS, (0, ObjectConstructor_1.objectConstructor)(target)).set(propertyKey, MemberDeclarations_js_1.REMOVED);
+}
+/**
+ * Get object inject items by its prototype: the ones of the class and of its parents, the closest declaration of a
+ * property winning
+ * @param target
+ * @constructor
+ */
+function getObjectInjectItemsByPrototype(target) {
+    return (0, MemberDeclarations_js_1.mergedDeclarations)(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_INJECTS, (0, ObjectConstructor_1.objectConstructor)(target));
+}
+/**
+ * Mark object as autoload
+ * @param target
+ * @constructor
+ */
+function markObjectAsAutoload(target) {
+    if (!Reflect.hasOwnMetadata(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_AUTOLOAD, target))
+        Reflect.defineMetadata(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_AUTOLOAD, true, target);
+    return target;
+}
+/**
+ * Whether an object is autoload object or not
+ * @param target
+ * @constructor
+ */
+function getObjectIsAutoload(target) {
+    return !!Reflect.getOwnMetadata(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_AUTOLOAD, target);
+}

package/dist/cjs/lib/base/internal/ObjectOptionsCheck.d.ts

@@ -0,0 +1,12 @@
+import { BaseObject } from '../BaseObject.js';
+import { LoadObjectOptions } from '../../../options/LoadObjectOptions.js';
+/**
+ * Check the options of the objects declared in a module, before any of them is created (an object never created is
+ * checked too): an invalid value of a configurable property is an error, an option which is not a configurable property
+ * and which the class does not accept (see BaseObject.acceptsOption()) is a warning. The values are validated as the
+ * objects validate them, without their transforms. The options not given are not checked (they may be given when the
+ * object is got), nor the properties validated asynchronously (by external rules), which the object validates
+ * @param loadOptions
+ * @constructor
+ */
+export declare function checkObjectOptions(loadOptions: (LoadObjectOptions | typeof BaseObject | string)[]): void;