@adaas/a-concept 0.0.2 → 0.0.4

package/src/{containers → base}/A-Config/A-Config.container.ts

@@ -1,26 +1,26 @@
 import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
-import { A_Config } from "./A-Config.namespace";
-import { A_Load } from "@adaas/a-concept/decorators/A-ConceptLifecycle/A-Load/A-Load.decorator";
+import { ConfigReader } from "./components/ConfigReader.component";
+import { A_Logger } from "../A-Logger/A-Logger.component";
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
 import { A_Polyfills } from "@adaas/a-utils";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 import { FileConfigReader } from "./components/FileConfigReader.component";
 import { ENVConfigReader } from "./components/ENVConfigReader.component";
-import { ConfigReader } from "./components/ConfigReader.component";
-import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+
 
 
 
-// @A_Injectable({
 
-// })
-export class A_ConfigInitializer extends A_Container<A_Config> {
+export class A_ConfigLoader extends A_Container<['load', 'read']> {
 
     private reader!: ConfigReader
 
 
-    @A_Load({
-    })
+
     async identifyReader(
-        // @A_Inject(A_LoggerContext) logger: A_LoggerContext
+        @A_Inject(A_Scope) scope: A_Scope,
+        @A_Inject(A_Logger) logger: A_Logger
     ) {
 
         // OR Inject the logger by calling Context Provider
@@ -30,17 +30,17 @@ export class A_ConfigInitializer extends A_Container<A_Config> {
 
         switch (true) {
 
-            case A_Context.environment === 'server' && !!fs.existsSync(`${this.namespace}.conf.json`):
-                this.reader = A_Context.resolve(FileConfigReader);
+            case A_Context.environment === 'server' && !!fs.existsSync(`${scope.name}.conf.json`):
+                this.reader = scope.resolve(FileConfigReader);
                 break;
 
 
-            case A_Context.environment === 'server': !fs.existsSync(`${this.namespace}.conf.json`)
-                this.reader = A_Context.resolve(ENVConfigReader);
+            case A_Context.environment === 'server': !fs.existsSync(`${scope.name}.conf.json`)
+                this.reader = scope.resolve(ENVConfigReader);
                 break;
 
             case A_Context.environment === 'browser':
-                this.reader = A_Context.resolve(ENVConfigReader);
+                this.reader = scope.resolve(ENVConfigReader);
                 break;
 
             default:
@@ -48,13 +48,14 @@ export class A_ConfigInitializer extends A_Container<A_Config> {
         }
     }
 
-
-    @A_Load({})
     async readVariables() {
-        const config = await this.reader.read(this.namespace.CONFIG_PROPERTIES);
+        // const config = await this.reader.read(this.namespace.CONFIG_PROPERTIES);
 
-        this.namespace.set(config);
-    }
 
+    }
 
 }
+
+
+
+const foo = new A_ConfigLoader({});

package/src/{containers/A-Config/A-Config.namespace.ts → base/A-Config/A-Config.context.ts}

@@ -1,13 +1,17 @@
-import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
+import { A_CommonHelper, A_TYPES__Required } from "@adaas/a-utils";
 import { A_TYPES__ConfigContainerConstructor } from "./A-Config.types";
+import { A_Fragment } from "@adaas/a-concept/global/A-Fragment/A-Fragment.class";
 
 
 export class A_Config<
     T extends string = any
-> extends A_Namespace<A_TYPES__ConfigContainerConstructor<T>> {
+> extends A_Fragment {
+
+    config: A_TYPES__ConfigContainerConstructor<T>;
 
     // Custom properties
     private VARIABLES: Map<string, any> = new Map<string, any>();
+
     CONFIG_PROPERTIES: T[] = [];
 
     protected DEFAULT_ALLOWED_TO_READ_PROPERTIES = [
@@ -18,13 +22,16 @@ export class A_Config<
 
 
     constructor(
-        config: A_TYPES__ConfigContainerConstructor<T>
+        config: A_TYPES__Required<Partial<A_TYPES__ConfigContainerConstructor<T>>, ['variables']>
     ) {
         super(config);
 
-        const targetConfig = config
+        this.config = A_CommonHelper.deepCloneAndMerge<A_TYPES__ConfigContainerConstructor<T>>(config as any, {
+            name: this.name,
+            defaults: {} as Record<T, any>
+        });
 
-        this.CONFIG_PROPERTIES = targetConfig.variables ? targetConfig.variables : [];
+        this.CONFIG_PROPERTIES = this.config.variables ? this.config.variables : [];
     }
 
 

package/src/{containers → base}/A-Config/A-Config.types.ts

@@ -1,14 +1,20 @@
-import { A_TYPES__NamespaceConstructor } from "@adaas/a-concept/global/A-Namespace/A_Namespace.types";
+import { A_TYPES__FragmentConstructor } from "@adaas/a-concept/global/A-Fragment/A-Fragment.types";
+import { A_TYPES__Dictionary } from "@adaas/a-utils";
 
 export type A_TYPES__ConfigContainerConstructor<T extends string> = {
+
     /**
-     * The name of the Config Container
+     * Allows to define the names of variable to be loaded
      */
     variables?: Array<T>
+
     /**
      * Allows to set the default values for the variables
      */
-    defaults?: Record<T, any>
+    defaults?: {
+        [key in T]?: any
+    }
+
     // credentials?: {
     //     /**
     //      * Api Credentials Client ID to authenticate the SDK
@@ -23,7 +29,7 @@ export type A_TYPES__ConfigContainerConstructor<T extends string> = {
     //     client_secret: string
 
     // }
-} & A_TYPES__NamespaceConstructor
+} & A_TYPES__FragmentConstructor;
 
 
 export type A_TYPES__ConfigContainer_DefaultProperties = 'CONFIG_SDK_VALIDATION'

package/src/{containers → base}/A-Config/components/ConfigReader.component.ts

@@ -1,12 +1,16 @@
-import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
-import { A_Config } from "../A-Config.namespace";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
 
 
 
 /**
  * Config Reader
  */
-export class ConfigReader extends A_Component<A_Config> {
+export class ConfigReader {
+
+    constructor(
+        @A_Inject(A_Scope) protected scope: A_Scope
+    ) { }
 
 
     /**

package/src/{containers → base}/A-Config/components/ENVConfigReader.component.ts

@@ -10,7 +10,7 @@ export class ENVConfigReader extends ConfigReader {
      * @param property 
      */
     getConfigurationProperty_ENV_Alias(property: string): string {
-        return `${A_CommonHelper.toUpperSnakeCase(this.namespace.name)}_${A_CommonHelper.toUpperSnakeCase(property)}`;
+        return `${A_CommonHelper.toUpperSnakeCase(this.scope.name)}_${A_CommonHelper.toUpperSnakeCase(property)}`;
     }
 
 

package/src/{containers → base}/A-Config/components/FileConfigReader.component.ts

@@ -26,7 +26,7 @@ export class FileConfigReader extends ConfigReader {
     ): Promise<Record<T, any>> {
         const fs = await A_Polyfills.fs();
         try {
-            const data = fs.readFileSync(`${this.namespace.name}.conf.json`, 'utf8');
+            const data = fs.readFileSync(`${this.scope.name}.conf.json`, 'utf8');
 
             const config: Record<T, any> = JSON.parse(data);
 

package/src/base/A-Errors/A-Errors.component.ts

@@ -0,0 +1,102 @@
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Errors } from "./A-Errors.context";
+import { A_CONSTANTS__ERROR_CODES, A_Error, A_ServerError, ASEID } from "@adaas/a-utils";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+
+export class A_ErrorsManager {
+
+    constructor(
+        @A_Inject(A_Scope) protected scope: A_Scope,
+        @A_Inject(A_Errors) protected errors: A_Errors
+    ) {
+
+    }
+
+
+
+
+    throw(
+        error: Error | unknown | any
+    ): never
+    throw(
+        code: A_CONSTANTS__ERROR_CODES | string
+    ): never
+    throw(
+        error: A_Error | A_ServerError
+    ): never
+    throw(
+        param: A_CONSTANTS__ERROR_CODES | string | A_Error | A_ServerError
+    ): never {
+        switch (true) {
+            // In case of error code
+            case typeof param === 'string':
+                const template = this.errors.get(param);
+                const namedCode = `${A_Context.root}@${this.scope.name}:error:${template.code}`
+
+                if ('serverCode' in template)
+                    throw new A_ServerError({
+                        ...template,
+                        code: namedCode
+                    });
+                else
+                    throw new A_Error({
+                        ...template,
+                        code: namedCode
+                    })
+
+            // In case of error object
+            case param instanceof A_Error:
+                throw param;
+
+            // Otherwise wrap the error
+            default:
+                throw this.wrap(param);
+        }
+    }
+
+
+    /**
+     *  This method wraps an error into the SDK error object.
+     * 
+     * @param error 
+     * @returns 
+     */
+    wrap(error: Error | A_Error | unknown | any): A_ServerError | A_Error {
+
+        switch (true) {
+            case error instanceof A_Error:
+                let newCode = `${A_Context.root}@${this.scope.name}:error:${error.code}`;
+
+                if (ASEID.isASEID(error.code)) {
+                    const aseid = new ASEID(error.code);
+
+                    if (aseid.scope !== this.scope.name)
+                        newCode = `${A_Context.root}@${this.scope.name}:error:${aseid.id}`;
+                }
+
+                if ('serverCode' in error)
+                    return new A_ServerError({
+                        originalError: error,
+                        code: newCode,
+                        serverCode: error.serverCode,
+                        name: error.name,
+                        message: error.message,
+                        link: error.link,
+                        description: error.description
+                    });
+                else
+                    return new A_Error({
+                        originalError: error,
+                        code: newCode,
+                        name: error.name,
+                        message: error.message,
+                        link: error.link,
+                        description: error.description
+                    });
+
+            default:
+                return new A_Error(error);
+        }
+    }
+}

package/src/{containers/A-Errors/A-Errors.namespace.ts → base/A-Errors/A-Errors.context.ts}

@@ -1,23 +1,26 @@
-import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
 import { A_CONSTANTS__ERROR_CODES, A_Error, A_ServerError, A_TYPES__Dictionary, A_TYPES__Error, A_TYPES__ServerError } from "@adaas/a-utils";
 import { A_TYPES__A_ErrorsConstructor } from "./A-Errors.types";
 import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-utils/dist/src/constants/errors.constants";
+import { A_Fragment } from "@adaas/a-concept/global/A-Fragment/A-Fragment.class";
 
 
-export class A_Errors extends A_Namespace<Partial<A_TYPES__A_ErrorsConstructor>> {
-
-
+export class A_Errors extends A_Fragment {
 
     protected registeredErrors: Map<string, A_TYPES__Error | A_TYPES__ServerError> = new Map();
 
     constructor(
         params: Partial<A_TYPES__A_ErrorsConstructor>
     ) {
-        super(params);
+
+        super({
+            ...params,
+            name: params.name || 'a-errors'
+        });
 
         if (params.errors) {
             this.addRegistry(params.errors);
         }
+
         this.addRegistry(A_CONSTANTS__DEFAULT_ERRORS);
     }
 
@@ -45,60 +48,42 @@ export class A_Errors extends A_Namespace<Partial<A_TYPES__A_ErrorsConstructor>>
      * @param error 
      */
     registerError(error: A_TYPES__Error): A_Errors {
-        this.registeredErrors.set(error.code, {
-            ...error,
-            code: `${this.name}@error:${error.code}`
-        });
+        this.registeredErrors.set(error.code, error);
 
         return this;
     }
 
+
     /**
      * This method returns an error object by its code.
      * 
      * @param code 
      * @returns 
      */
-    getError(code: A_CONSTANTS__ERROR_CODES | string): A_ServerError | A_Error | undefined {
+    get(code: A_CONSTANTS__ERROR_CODES | string): A_TYPES__Error | A_TYPES__ServerError {
         let template = this.registeredErrors.get(code);
 
         if (!template)
-            template = this.registeredErrors.get(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR);
+            template = this.registeredErrors.get(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR)!;
 
-        if ((template as A_TYPES__ServerError).serverCode) {
-            return new A_ServerError(template as A_TYPES__ServerError);
-        } else {
-            return new A_Error(template);
-        }
+        return template;
     }
 
 
     /**
+     * Allows to throw an error by its code. 
+     * [!] BUT WITHOUT Connection to particular Scope
+     * 
      * This method throws an error by its code.
      * 
      * @param code 
      */
-    throw(code: A_CONSTANTS__ERROR_CODES | string): never {
-
-        const err = this.getError(code);
-
-        throw err;
-    }
-
-
-    /**
-     *  This method wraps an error into the SDK error object.
-     * 
-     * @param error 
-     * @returns 
-     */
-    wrap(error: Error | A_Error | unknown): A_ServerError | A_Error {
-        if (error instanceof A_Error) {
-            return new A_ServerError(error);
-        }
-
-        return new A_Error(error);
-    }
-
-
+    // throw(code: A_CONSTANTS__ERROR_CODES | string): never {
+    //     const template = this.get(code);
+
+    //     if ('serverCode' in template)
+    //         throw new A_ServerError(template);
+    //     else
+    //         throw new A_Error(template)
+    // }
 } 

package/src/{containers → base}/A-Errors/A-Errors.types.ts

@@ -1,6 +1,6 @@
-import { A_TYPES__NamespaceConstructor } from "@adaas/a-concept/global/A-Namespace/A_Namespace.types"
+import { A_TYPES__FragmentConstructor } from "@adaas/a-concept/global/A-Fragment/A-Fragment.types"
 import { A_TYPES__Dictionary, A_TYPES__Error } from "@adaas/a-utils"
 
 export type A_TYPES__A_ErrorsConstructor = {
     errors: A_TYPES__Dictionary<A_TYPES__Error> | A_TYPES__Error[]
-} & A_TYPES__NamespaceConstructor
+} & A_TYPES__FragmentConstructor

package/src/base/A-Logger/A-Logger.component.ts

@@ -0,0 +1,169 @@
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Error } from "@adaas/a-utils";
+import { A_Config } from "../A-Config/A-Config.context";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+
+
+
+export class A_Logger {
+
+    constructor(
+        @A_Inject(A_Scope) protected scope: A_Scope,
+        @A_Inject(A_Config) protected config: A_Config
+    ) {
+    }
+
+    readonly colors = {
+        green: '32',
+        blue: '34',
+        red: '31',
+        yellow: '33',
+        gray: '90',
+        magenta: '35',
+        cyan: '36',
+        white: '37',
+        pink: '95',
+    } as const
+
+
+    get scopeLength() {
+        return this.scope.name.length;
+    }
+
+
+    compile(
+        color: keyof typeof this.colors,
+        ...args: any[]
+    ): Array<string> {
+
+        return [
+            `\x1b[${this.colors[color]}m[${this.scope.name}] |${this.getTime()}|`,
+            (
+                args.length > 1
+                    ? '\n' + `${' '.repeat(this.scopeLength + 3)}|-------------------------------`
+                    : ''
+
+            ),
+            ...(args
+                .map((arg, i) => {
+
+
+                    switch (true) {
+                        case arg instanceof A_Error:
+                            return this.compile_A_Error(arg);
+
+                        case arg instanceof Error:
+                            return this.compile_Error(arg);
+
+                        case typeof arg === 'object':
+                            return JSON.stringify(arg, null, 2)
+                                .replace(/\n/g, '\n' + `${' '.repeat(this.scopeLength + 3)}| `);
+
+                        default:
+                            return String(
+                                ((i > 0 || args.length > 1) ? '\n' : '')
+                                + arg)
+                                .replace(/\n/g, '\n' + `${' '.repeat(this.scopeLength + 3)}| `)
+                    }
+                })),
+            (
+                args.length > 1
+                    ? '\n' + `${' '.repeat(this.scopeLength + 3)}|-------------------------------\x1b[0m`
+                    : '\x1b[0m'
+            )
+        ]
+    }
+
+
+    log(...args) {
+        if (!this.config.get('CONFIG_VERBOSE'))
+            return;
+
+        console.log(...this.compile('blue', ...args));
+    }
+
+    warning(...args) {
+        if (!this.config.get('CONFIG_VERBOSE'))
+            return;
+
+        console.log(...this.compile('yellow', ...args));
+    }
+
+    error(...args) {
+        if (this.config.get('CONFIG_IGNORE_ERRORS'))
+            return;
+
+        return console.log(...this.compile('red', ...args));
+    }
+
+
+    protected log_A_Error(error: A_Error) {
+        const time = this.getTime();
+
+        console.log(`\x1b[31m[${this.scope.name}] |${time}| ERROR ${error.code}
+${' '.repeat(this.scopeLength + 3)}| ${error.message}
+${' '.repeat(this.scopeLength + 3)}| ${error.description} 
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}| ${error.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+\x1b[0m`
+            + (error.originalError ? `\x1b[31m${' '.repeat(this.scopeLength + 3)}| Wrapped From  ${error.originalError.message}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}| ${error.originalError.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+\x1b[0m`: '')
+            + (error.link ? `\x1b[31m${' '.repeat(this.scopeLength + 3)}| Read in docs: ${error.link}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+\x1b[0m`: ''));
+
+    }
+
+    protected compile_A_Error(error: A_Error): string {
+        const time = this.getTime();
+
+        return '\n' +
+
+            `${' '.repeat(this.scopeLength + 3)}|-------------------------------` +
+            '\n' +
+            `${' '.repeat(this.scopeLength + 3)}|  Error:  | ${error.code}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}|${' '.repeat(10)}| ${error.message}
+${' '.repeat(this.scopeLength + 3)}|${' '.repeat(10)}| ${error.description} 
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}| ${error.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------`
+            +
+            (error.originalError ? `${' '.repeat(this.scopeLength + 3)}| Wrapped From  ${error.originalError.message}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}| ${error.originalError.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------` : '')
+            +
+            (error.link ? `${' '.repeat(this.scopeLength + 3)}| Read in docs: ${error.link}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------` : '');
+
+    }
+
+
+    protected compile_Error(error: Error): string {
+        return JSON.stringify({
+            name: error.name,
+            message: error.message,
+            stack: error.stack?.split('\n')
+                .map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`)
+                .join('\n')
+
+        }, null, 2)
+            .replace(/\n/g, '\n' + `${' '.repeat(this.scopeLength + 3)}| `)
+            .replace(/\\n/g, '\n')
+    }
+
+
+
+    protected getTime() {
+        const now = new Date();
+        const minutes = String(now.getMinutes()).padStart(2, '0');
+        const seconds = String(now.getSeconds()).padStart(2, '0');
+        const milliseconds = String(now.getMilliseconds()).padStart(4, '0');
+        return `${minutes}:${seconds}:${milliseconds}`;
+    }
+}

package/src/constants/A_ConceptLifecycle.constants.ts

@@ -1,12 +1,12 @@
-import { A_TYPES__ConceptLifecycle_MethodDeclarationConfig } from "../decorators/A-ConceptLifecycle/A-ConceptLifecycle.decorator.types";
+// import { A_TYPES__ConceptLifecycle_MethodDeclarationConfig } from "../decorators/A-ConceptLifecycle/A-ConceptLifecycle.decorator.types";
 
 
 
-export const A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG: A_TYPES__ConceptLifecycle_MethodDeclarationConfig = {
-    name: '',
-    behavior: 'sync',
-    type: 'extension',
-    after: [],
-    before: [],
-    override: []
-} 
+// export const A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG: A_TYPES__ConceptLifecycle_MethodDeclarationConfig = {
+//     name: '',
+//     behavior: 'sync',
+//     type: 'extension',
+//     after: [],
+//     before: [],
+//     override: []
+// } 

package/src/decorators/A-Feature/A-Feature-Define.decorator.ts

@@ -0,0 +1,57 @@
+import {
+    A_TYPES__A_FeatureDecoratorConfig,
+    A_TYPES__A_FeatureDecoratorDescriptor,
+} from "./A-Feature.decorator.types";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A-Container.types";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+
+
+/**
+ * A-Feature decorator
+ * 
+ * This decorator allows to define a custom lifecycle stage for the Container.
+ * These stages are executed in a container-specific order and can be extended by components that are injected into the container.
+ * This approach allows to create a flexible and extendable architecture for the application.
+ * 
+ * The main difference between the A-Feature and A-Feature decorators is that A-Feature methods can be inherited and overridden by child classes.
+ * 
+ * 
+ * @param params 
+ * @returns 
+ */
+export function A_Feature_Define(
+    config: Partial<A_TYPES__A_FeatureDecoratorConfig> = {}
+) {
+    return function (
+        target: A_Container<any>,
+        propertyKey: string,
+        descriptor: A_TYPES__A_FeatureDecoratorDescriptor
+    ) {
+
+        // Get the existed metadata or create a new one
+        const existedMeta = A_Context
+            .meta(target)
+            .get(A_TYPES__ContainerMetaKey.FEATURES)
+            || new Map();
+
+
+
+        // Set the metadata of the method to define a custom Feature with name 
+        existedMeta.set(propertyKey, {
+            handler: propertyKey,
+            config: {
+                ...config,
+                name: `${target.constructor.name}.${propertyKey || config.name}`,
+            }
+        });
+
+        //  Update the metadata of the container with the new Feature definition
+        A_Context
+            .meta(target)
+            .set(
+                A_TYPES__ContainerMetaKey.FEATURES,
+                existedMeta
+            );
+    };
+}