@adaas/a-concept 0.0.64 → 0.1.1

package/src/global/A-Context/A-Context.class.ts

@@ -1,298 +1,413 @@
 import {
-    A_CommonHelper,
-    A_Error,
-    A_Polyfills,
-} from "@adaas/a-utils";
+    A_TYPES__Scope_Init,
+    A_TYPES__ScopeConfig,
+    A_TYPES__ScopeLinkedComponents,
+    A_TYPES_ScopeDependentComponents
+} from "../A-Scope/A-Scope.types";
+import {
+    A_TYPES__MetaLinkedComponentConstructors,
+    A_TYPES__MetaLinkedComponents
+} from "../A-Meta/A-Meta.types";
+import {
+    A_TYPES__FeatureAvailableComponents,
+    A_TYPES__FeatureDefineDecoratorMeta
+} from "../A-Feature/A-Feature.types";
 import { A_Component } from "../A-Component/A-Component.class";
-import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_Feature } from "../A-Feature/A-Feature.class";
 import { A_Container } from "../A-Container/A-Container.class";
 import { A_Scope } from "../A-Scope/A-Scope.class";
-import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types";
 import { A_Meta } from "../A-Meta/A-Meta.class";
 import { A_ComponentMeta } from "../A-Component/A-Component.meta";
 import { A_ContainerMeta } from "../A-Container/A-Container.meta";
-import { A_TYPES__EntityMetaKey } from "../A-Entity/A-Entity.types";
 import { A_Entity } from "../A-Entity/A-Entity.class";
 import { A_EntityMeta } from "../A-Entity/A-Entity.meta";
-import { A_TYPES__FeatureConstructor } from "../A-Feature/A-Feature.types";
 import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
-import { A_TYPES__ContainerMetaKey } from "../A-Container/A-Container.types";
-import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.types";
-import { A_TYPES__ConceptStage } from "../A-Concept/A_Concept.types";
-import { A_TYPES__A_DefineDecorator_Meta } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/env.constants";
-import { A_Command } from "../A-Command/A-Command.class";
-import { A_TYPES__CommandMetaKey } from "../A-Command/A-Command.types";
+import { A_TYPES__EntityMetaKey } from "../A-Entity/A-Entity.constants";
+import { A_TYPES__ContainerMetaKey } from "../A-Container/A-Container.constants";
+import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.constants";
+import { A_TYPES__ContextEnvironment } from "./A-Context.types";
+import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
+import { A_ContextError } from "./A-Context.error";
+import { A_TYPES__Container_Constructor } from "../A-Container/A-Container.types";
+import { A_TYPES__Entity_Constructor } from "../A-Entity/A-Entity.types";
+import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types";
+import { A_FormatterHelper } from "@adaas/a-concept/helpers/A_Formatter.helper";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_TYPES__InjectableTargets } from "../A-Inject/A-Inject.types";
+import { A_TYPES__ConceptAbstraction } from "../A-Concept/A-Concept.types";
 
 
 
-/**
- * Namespace Provider is responsible for providing the Namespace to the Containers and other Namespaces.
- * This class stores all Namespaces across the Program.
- *  
- * Namespace provider is a singleton class that is used to store all the Namespaces in the program.
- * 
- */
 export class A_Context {
-
-    static instance: A_Context;
-
+    // ====================================================================================================
+    // ================================ STATIC PROPERTIES =================================================
+    // ====================================================================================================
     /**
-     * A set of globally registered containers.
+     * Default name of the application from environment variable A_CONCEPT_NAME
+     * 
+     * [!] If environment variable is not set, it will default to 'a-concept'
      */
-    protected containers: WeakMap<A_Container, A_Scope> = new WeakMap();
-
+    static get concept() {
+        return process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME] || 'a-concept';
+    }
     /**
-     * A set of globally registered features.
+     * Root scope of the application from environment variable A_CONCEPT_ROOT_SCOPE
+     * 
+     * [!] If environment variable is not set, it will default to 'root'
      */
-    protected features: WeakMap<A_Feature, A_Scope> = new WeakMap();
-
-
-    protected commands: WeakMap<A_Command, A_Scope> = new WeakMap();
-
-
+    static get root(): A_Scope {
+        return this.getInstance()._root;
+    }
     /**
-     * Uses to store the scope of every element in the program. 
+     * Environment the application is running in.
+     * Can be either 'server' or 'browser'.
+     * [!] Determined by checking if 'window' object is available.
      */
-    protected registry: WeakMap<
-        A_Container |
-        A_Feature |
-        A_Component |
-        A_Fragment |
-        A_Entity,
-        A_Scope
-    > = new WeakMap();
-
+    static get environment(): A_TYPES__ContextEnvironment {
+        let testEnvironment: A_TYPES__ContextEnvironment = 'browser';
 
+        try {
+            testEnvironment = window.location ? 'browser' : 'server';
+        } catch (error) {
+            testEnvironment = 'server';
+        }
 
+        return testEnvironment;
+    }
 
     /**
-     * A set of allocated scopes per every element in the program.
+     * Singleton instance of the Context
      */
-    protected containersMeta: Map<typeof A_Container.constructor, A_ContainerMeta> = new Map();
-    protected componentsMeta: Map<typeof A_Component, A_ComponentMeta> = new Map();
-    protected entitiesMeta: Map<typeof A_Entity.constructor, A_EntityMeta> = new Map();
-
-    // uses to allow to store custom meta data
-    protected customMeta: Map<typeof A_Container.constructor, A_Meta<any>> = new Map();
-
-
+    private static _instance: A_Context;
+    // ====================================================================================================
+    // ================================ INTERNAL REGISTRY =================================================
+    // ====================================================================================================
     /**
-     * Root Namespace is a Namespace that is used to run the program.
+     * Root Scope of the Concept and Environment
+     *
+     * Root scope is the top-level scope that all other scopes inherit from.
+     * It stores global configurations and settings and ALL SHAREABLE RESOURCES.
+     * 
+     * [!] Root scope is created automatically when the Context is initialized.
+     * [!] Root scope name can be configured using environment variable A_CONCEPT_ROOT_SCOPE
      */
     private _root!: A_Scope
+    /**
+     * A registry that keeps track of scopes for all components (Containers, Features, Commands) 
+     * Which can issue a scope allocation.
+     */
+    protected _registry: WeakMap<A_TYPES__ScopeLinkedComponents, A_Scope> = new WeakMap();
+    /**
+     * This is a registry that stores an issuer of each scope allocation.
+     * It helps to track which component (Container, Feature, Command) allocated a specific scope.
+     */
+    protected _scopeIssuers: WeakMap<A_Scope, A_TYPES__ScopeLinkedComponents> = new WeakMap();
+    /**
+     * Stores a context associated with a specific component that depends on a scope.
+     * uses for quick retrieval of the scope for the component.
+     */
+    protected _scopeStorage: WeakMap<A_TYPES_ScopeDependentComponents, A_Scope> = new WeakMap();
+    /**
+     * Stores meta information for different component types by their constructors.
+     * Meta provides to store extra information about the class behavior and configuration.
+     */
+    protected _metaStorage: Map<A_TYPES__MetaLinkedComponentConstructors, A_Meta> = new Map();
+
 
 
+    /**
+     * Private constructor to enforce singleton pattern.
+     * 
+     * [!] This class should not be instantiated directly. Use A_Context.getInstance() instead.
+     */
     private constructor() {
-        this._root = new A_Scope({
-            name: process && process.env ? process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE] || 'a-concept' : 'a-concept'
-        });
-    }
+        let name = 'root';
 
+        if (A_Context.environment === 'server')
+            name = process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] || 'root';
 
+        if (A_Context.environment === 'browser')
+            name = (window as any)[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] || 'root';
 
-    // ===================================================================================================
-    // ================================ META OPERATIONS ==================================================
-    // ===================================================================================================
+        this._root = new A_Scope({ name });
+    }
 
 
 
     /**
      * Get the instance of the Namespace Provider.
      * 
+     * If the instance does not exist, it will be created.
+     * 
      * @returns 
      */
     static getInstance() {
-        if (!A_Context.instance) {
-            A_Context.instance = new A_Context();
+        if (!A_Context._instance) {
+            A_Context._instance = new A_Context();
         }
 
-        return A_Context.instance;
+        return A_Context._instance;
     }
 
-    static get root(): A_Scope {
-        return this.getInstance()._root;
-    }
 
-    static get environment(): 'server' | 'browser' {
-        return A_Polyfills.env;
-    }
 
+    /**
+     * Register method allows to register a component with a specific scope in the context.
+     * 
+     * @param component - Component to register with a specific scope. Can be either A_Container, A_Feature.
+     * @param scope - Scope to associate the component with.
+     * @returns 
+     */
+    static register(
+        /**
+         * Provide the scope that will be associated with the component.
+         */
+        scope: A_Scope,
+        /**
+         * Provide a component that needs to be registered with a specific scope.
+         */
+        component: A_TYPES_ScopeDependentComponents,
 
+    ): A_Scope {
+        // uses only for error messages
+        const componentName = (component as any)?.constructor?.name || String(component);
 
+        const instance = this.getInstance();
+
+        if (!component) throw new A_ContextError(
+            A_ContextError.InvalidRegisterParameterError,
+            `Unable to register component. Component cannot be null or undefined.`);
+        if (!scope) throw new A_ContextError(
+            A_ContextError.InvalidRegisterParameterError,
+            `Unable to register component. Scope cannot be null or undefined.`);
+        if (!this.isAllowedToBeRegistered(component)) throw new A_ContextError(
+            A_ContextError.NotAllowedForScopeAllocationError,
+            `Component ${componentName} is not allowed for scope allocation.`);
+
+        instance._scopeStorage.set(component, scope);
+
+        return scope;
+    }
+
+
+    /**
+     * Allocate method instantiates a new scope for the given component and registers it in the context.
+     * It bounds the component (Container, Feature) to a new scope that can be configured and used independently.
+     * 
+     * 
+     * @param component - Component to allocate the scope for. Can be either A_Container, A_Feature.
+     * @param importing  - Configuration of the scope that will be created for the component.
+     */
     static allocate(
-        component: any,
-        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
-    ): A_Scope
-    static allocate(
-        component: any,
-        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig> | A_Scope
-    ): A_Scope
-    static allocate(
-        feature: A_Feature,
-        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
-    ): A_Scope
-    static allocate(
-        feature: A_Feature,
-        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig> | A_Scope
+        /**
+         * Provide a component that needs a scope allocation.
+         */
+        component: A_TYPES__ScopeLinkedComponents,
     ): A_Scope
     static allocate(
-        container: A_Container,
-        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
+        /**
+         * Provide a component that needs a scope allocation.
+         */
+        component: A_TYPES__ScopeLinkedComponents,
+        /**
+         * Provide the scope that will be used as a base for the new scope.
+         */
+        importing: A_Scope
     ): A_Scope
     static allocate(
-        container: A_Container,
-        importing: A_Scope
+        /**
+         * Provide a component that needs a scope allocation.
+         */
+        component: A_TYPES__ScopeLinkedComponents,
+        /**
+         * Provide configuration for the scope that will be created for the component.
+         */
+        config: Partial<A_TYPES__Scope_Init & A_TYPES__ScopeConfig>
     ): A_Scope
     static allocate(
-        param1: A_Container | A_Feature | A_Component | any,
-        param2: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig> | A_Scope
+        component: A_TYPES__ScopeLinkedComponents,
+        importing?: Partial<A_TYPES__Scope_Init & A_TYPES__ScopeConfig> | A_Scope
     ): A_Scope {
-
+        // uses only for error messages
+        const componentName = (component as any)?.constructor?.name || String(component);
+
+        // ---------------------------------------------------------------------
+        // ----------------------Input Validation-------------------------------
+        // ---------------------------------------------------------------------
+        // 1) check if component is valid
+        if (!this.isAllowedForScopeAllocation(component))
+            throw new A_ContextError(A_ContextError.NotAllowedForScopeAllocationError, `Component of type ${componentName} is not allowed for scope allocation. Only A_Container, A_Feature are allowed.`);
         const instance = this.getInstance();
 
-        const newScope = param2 instanceof A_Scope ? param2 : new A_Scope(param2, param2);
-
-        if (!newScope.isInheritedFrom(A_Context.root)) {
-            newScope.inherit(A_Context.root);
-        }
-
-        switch (true) {
-            case param1 instanceof A_Container:
-                instance.containers.set(param1, newScope);
-
-                break;
-
-            case param1 instanceof A_Feature:
-                instance.features.set(param1, newScope);
-
-                break;
+        // 2) check if component already has a scope allocated
+        if (instance._registry.has(component))
+            throw new A_ContextError(A_ContextError.ComponentAlreadyHasScopeAllocatedError, `Component ${componentName} already has a scope allocated.`);
 
-            case param1 instanceof A_Command:
-                instance.commands.set(param1, newScope);
 
-                break;
+        // 3) Create a new scope for the component
+        const newScope = A_TypeGuards.isScopeInstance(importing)
+            ? importing
+            : new A_Scope(importing || {
+                name: componentName + '-scope'
+            }, importing);
 
-            default:
-                throw new Error(`[!] A-Concept Context: Unknown type of the parameter.`);
-        }
+        // 4) Make sure that the new scope inherits from the root scope
+        if (!newScope.isInheritedFrom(A_Context.root))
+            newScope.inherit(A_Context.root);
 
+        // 5) Register the component in the appropriate storage
+        instance._registry.set(component, newScope);
+        // Also register the issuer of the scope for faster tracking
+        instance._scopeIssuers.set(newScope, component);
 
+        // 6) Return the newly created scope
         return newScope;
     }
 
 
 
-
     /**
-     * Get or Create Meta for the specific class or instance.
-     * This method will return the existing meta if it exists, or create a new one if it doesn't.
-     * 
-     * Meta object contains custom metadata based on the class type.
-     * 
-     * @param container 
-     */
+      * Get or Create Meta for the specific class or instance.
+      * This method will return the existing meta if it exists, or create a new one if it doesn't.
+      * 
+      * Meta object contains custom metadata based on the class type.
+      * 
+      * @param container 
+      */
     static meta(
-        container: typeof A_Container,
+        /**
+         * Get meta for the specific container class by constructor.
+         */
+        container: A_TYPES__Container_Constructor,
     ): A_ContainerMeta
     static meta(
+        /**
+         * Get meta for the specific container instance.
+         */
         container: A_Container,
     ): A_ContainerMeta
     static meta(
+        /**
+         * Get meta for the specific entity class by constructor.
+         */
+        entity: A_TYPES__Entity_Constructor,
+    ): A_EntityMeta
+    static meta(
+        /**
+         * Get meta for the specific entity instance.
+         */
         entity: A_Entity,
-    ): A_ContainerMeta
+    ): A_EntityMeta
     static meta(
-        entity: typeof A_Entity,
-    ): A_ContainerMeta
+        /**
+         * Get meta for the specific component class by constructor.
+         */
+        component: A_TYPES__Component_Constructor,
+    ): A_ComponentMeta
     static meta(
-        component: string,
+        /**
+         * Get meta for the specific component instance.
+         */
+        component: A_Component,
     ): A_ComponentMeta
     static meta(
-        component: typeof A_Component,
+        /**
+         * Get meta for the specific component by its name.
+         */
+        component: string,
     ): A_ComponentMeta
     static meta(
-        component: A_Component,
+        /**
+         * Get meta for the specific injectable target (class or instance).
+         */
+        target: A_TYPES__InjectableTargets,
     ): A_ComponentMeta
     static meta<T extends Record<string, any>>(
-        constructor: typeof A_Component | typeof A_Container | A_Container
-            | A_Component
-            | A_Entity
-            | typeof A_Entity
-            | { new(...args: any[]): any }
-            | string
+        /**
+         * Get meta for the specific class or instance
+         */
+        constructor: new (...args: any[]) => any
     ): A_Meta<T>
+
     static meta<T extends Record<string, any>>(
-        param1: typeof A_Component | typeof A_Container | A_Container
-            | A_Component
-            | A_Entity
-            | typeof A_Entity
-            | { new(...args: any[]): any }
+        param1: A_TYPES__MetaLinkedComponentConstructors
+            | A_TYPES__MetaLinkedComponents
             | string
-    ): A_ContainerMeta | A_ComponentMeta | A_Meta<T> {
+    ): A_Meta<T> {
 
+        // Get the component name for error messages
+        const componentName = (param1 as any)?.constructor?.name || String(param1);
+        // Get the instance of the context
         const instance = this.getInstance();
 
-        let metaStorage: WeakMap<typeof A_Container.constructor, A_Meta<any>>;
-        let property: Function;
-        let metaType: typeof A_Meta<T> | typeof A_ContainerMeta | typeof A_ComponentMeta | typeof A_EntityMeta
+        if (!param1) throw new A_ContextError(A_ContextError.InvalidMetaParameterError, `Invalid parameter provided to get meta. Parameter cannot be null or undefined.`);
 
+        // Check if the parameter is allowed for meta storage
+        if (!(
+            this.isAllowedForMeta(param1)
+            || this.isAllowedForMetaConstructor(param1)
+            || A_TypeGuards.isString(param1)
+            || A_TypeGuards.isFunction(param1
+            ))
+        ) throw new A_ContextError(A_ContextError.InvalidMetaParameterError, `Invalid parameter provided to get meta. Component of type ${componentName} is not allowed for meta storage. Only A_Container, A_Component and A_Entity are allowed.`);
+
+        let property: A_TYPES__MetaLinkedComponentConstructors;
+        let metaType: typeof A_Meta<T> | typeof A_ContainerMeta | typeof A_ComponentMeta | typeof A_EntityMeta
 
         switch (true) {
             // 1) If param1 is instance of A_Container
-            case param1 instanceof A_Container: {
-
-                metaStorage = instance.containersMeta;
-                property = param1.constructor;
+            case A_TypeGuards.isContainerInstance(param1): {
+                property = param1.constructor as A_TYPES__Container_Constructor;
                 metaType = A_ContainerMeta;
 
                 break;
             }
             // 2) If param1 is class of A_Container
-            case A_CommonHelper.isInheritedFrom(param1, A_Container): {
-                metaStorage = instance.containersMeta;
+            case A_TypeGuards.isContainerConstructor(param1): {
                 property = param1 as typeof A_Container;
                 metaType = A_ContainerMeta;
 
                 break;
             }
             // 3) If param1 is instance of A_Component
-            case param1 instanceof A_Component: {
-                metaStorage = instance.componentsMeta;
-                property = param1.constructor;
+            case A_TypeGuards.isComponentInstance(param1): {
+                property = param1.constructor as A_TYPES__Component_Constructor;
                 metaType = A_ComponentMeta;
 
                 break;
             }
             // 4) If param1 is class of A_Component
-            case A_CommonHelper.isInheritedFrom(param1, A_Component): {
-                metaStorage = instance.componentsMeta;
+            case A_TypeGuards.isComponentConstructor(param1): {
                 property = param1 as typeof A_Component;
                 metaType = A_ComponentMeta;
 
                 break;
             }
             // 5) If param1 is instance of A_Entity
-            case param1 instanceof A_Entity: {
-                metaStorage = instance.entitiesMeta;
-                property = param1.constructor;
+            case A_TypeGuards.isEntityInstance(param1): {
+                property = param1.constructor as A_TYPES__Entity_Constructor;
                 metaType = A_ComponentMeta;
 
                 break;
             }
             // 6) If param1 is class of A_Entity
-            case A_CommonHelper.isInheritedFrom(param1, A_Entity): {
-                metaStorage = instance.entitiesMeta;
-                property = param1 as typeof A_Entity;
+            case A_TypeGuards.isEntityConstructor(param1): {
+                property = param1;
                 metaType = A_EntityMeta;
 
                 break;
             }
             // 7) If param1 is string then we need to find the component by its name
             case typeof param1 === 'string': {
-                metaStorage = instance.componentsMeta;
-                const found = Array.from(instance.componentsMeta).find(([c]) => c.name === param1)!;
-                if (!(found && found.length)) throw new A_Error(`Component with name ${param1} not found`);
+                const found = Array.from(instance._metaStorage)
+                    .find(([c]) => c.name === param1
+                        || c.name === A_FormatterHelper.toKebabCase(param1)
+                        || c.name === A_FormatterHelper.toPascalCase(param1)
+                    )!;
+                if (!(found && found.length))
+                    throw new A_ContextError(A_ContextError.InvalidMetaParameterError, `Invalid parameter provided to get meta. Component with name ${param1} not found in the meta storage.`);
+
                 property = found[0];
                 metaType = A_ComponentMeta;
 
@@ -300,22 +415,51 @@ export class A_Context {
             }
             // 8) If param1 is any other class or function
             default: {
-                metaStorage = instance.customMeta;
-                property = typeof (param1 as any) === 'function' ? param1 : param1.constructor;
+                property = param1;
                 metaType = A_Meta;
 
                 break;
             }
         }
 
-
-        if (!metaStorage.has(property)) {
-            const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new metaType();
-            metaStorage.set(property, new metaType().from(inheritMeta as any));
+        // Check if the meta already exists for the property, if not create a new one
+        if (!instance._metaStorage.has(property)) {
+            const inheritMeta = instance._metaStorage.get(Object.getPrototypeOf(property)) || new metaType();
+            instance._metaStorage.set(property, new metaType().from(inheritMeta as any));
         }
 
+        // Return the meta for the property
+        return instance._metaStorage.get(property)!;
+    }
+
 
-        return metaStorage.get(property)!;
+    /**
+     * 
+     * This method allows to get the issuer of a specific scope.
+     * 
+     * @param scope - Scope to get the issuer for.
+     * @returns - Component that issued the scope.
+     */
+    static issuer(
+        /**
+         * Provide the scope to get its issuer.
+         */
+        scope: A_Scope
+    ): A_TYPES__ScopeLinkedComponents {
+
+        const instance = this.getInstance();
+
+        if (!scope) throw new A_ContextError(
+            A_ContextError.InvalidComponentParameterError,
+            `Invalid parameter provided to get scope issuer. Parameter cannot be null or undefined.`
+        );
+
+        if (!instance._scopeIssuers.has(scope)) throw new A_ContextError(
+            A_ContextError.ScopeNotFoundError,
+            `Invalid parameter provided to get scope issuer. Provided scope does not have an issuer registered.`
+        );
+
+        return instance._scopeIssuers.get(scope)!;
     }
 
 
@@ -329,127 +473,221 @@ export class A_Context {
      * 
      * @param entity 
      */
-    static scope(
-        entity: A_Entity
+    static scope<T extends A_Entity>(
+        /**
+         * Provide an entity to get its scope.
+         */
+        entity: T
     ): A_Scope
-    static scope(
-        component: A_Component
+    static scope<T extends A_Component>(
+        /**
+         * Provide a component to get its scope.
+         */
+        component: T
     ): A_Scope
-    static scope(
-        container: A_Container
+    static scope<T extends A_Container>(
+        /**
+         * Provide a container to get its scope.
+         */
+        container: T
     ): A_Scope
-    static scope(
-        feature: A_Fragment
+    static scope<T extends A_Feature>(
+        /**
+         * Provide a feature to get its scope.
+         */
+        feature: T
     ): A_Scope
-    static scope(
-        feature: A_Feature
+    static scope<T extends A_Fragment>(
+        /**
+         * Provide a fragment to get its scope.
+         */
+        fragment: T
     ): A_Scope
-    static scope(
-        param1: A_Feature | A_Container | A_Component | A_Entity | A_Fragment
-    ): A_Scope | undefined {
+    static scope<T extends A_TYPES__ScopeLinkedComponents | A_TYPES_ScopeDependentComponents>(
+        param1: T
+    ): A_Scope {
+
+        // for error messages
+        const name = (param1 as any)?.constructor?.name || String(param1);
 
+        // Get the instance of the context
         const instance = this.getInstance();
 
-        switch (true) {
-            case param1 instanceof A_Container:
-                return instance.containers.get(param1);
+        // Input validation
+        if (!param1) throw new A_ContextError(A_ContextError.InvalidScopeParameterError, `Invalid parameter provided to get scope. Parameter cannot be null or undefined.`);
+
+        // Check if the parameter is allowed for scope allocation
+        if (!this.isAllowedForScopeAllocation(param1)
+            && !this.isAllowedToBeRegistered(param1)
+        )
+            throw new A_ContextError(A_ContextError.InvalidScopeParameterError, `Invalid parameter provided to get scope. Component of type ${name} is not allowed for scope allocation.`);
 
-            case param1 instanceof A_Feature:
-                return instance.features.get(param1);
+        switch (true) {
+            case this.isAllowedForScopeAllocation(param1):
 
-            case param1 instanceof A_Entity:
-                return instance.registry.get(param1);
+                // Check if the parameter has a scope allocated
+                if (!instance._registry.has(param1))
+                    throw new A_ContextError(
+                        A_ContextError.ScopeNotFoundError,
+                        `Invalid parameter provided to get scope. Component of type ${name} does not have a scope allocated. Make sure to allocate a scope using A_Context.allocate() method before trying to get the scope.`
+                    );
 
-            case param1 instanceof A_Component:
-                return instance.registry.get(param1);
+                // If the parameter is allowed for scope allocation, return the scope
+                return instance._registry.get(param1)!;
 
-            case param1 instanceof A_Fragment:
-                return instance.registry.get(param1);
+            case this.isAllowedToBeRegistered(param1):
 
-            case param1 instanceof A_Command:
-                return instance.commands.get(param1);
+                // Check if the parameter has a scope registered
+                if (!instance._scopeStorage.has(param1))
+                    throw new A_ContextError(
+                        A_ContextError.ScopeNotFoundError,
+                        `Invalid parameter provided to get scope. Component of type ${name} does not have a scope registered. Make sure to register the component using A_Context.register() method before trying to get the scope.`
+                    );
 
+                // If the parameter is allowed to be registered, return the scope from the storage
+                return instance._scopeStorage.get(param1)!;
             default:
-                throw new Error(`[!] A-Concept Context: Unknown type of the parameter.`);
+                throw new A_ContextError(A_ContextError.InvalidScopeParameterError, `Invalid parameter provided to get scope. Component of type ${name} is not allowed to be registered.`);
         }
     }
 
 
+    // ==========================================================================================================
+    // ================================== FEATURE MANAGEMENT ====================================================
+    // ==========================================================================================================
+    // ----------------------------------------------------------------------------------------------------------
+    // -----------------------------------Primary Methods -------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------------------
+    /**
+     * Returns a template of the feature that can be then used to create a new A-Feature Instance
+     * 
+     * [!] Note: Steps/Stages included are fully dependent on the scope provided since it dictates which components are active and can provide extensions for the feature.
+     * 
+     * @param name 
+     */
+    static featureTemplate(
+        /**
+         * Provide the name of the feature to get the template for. Regular expressions are also supported to match multiple features.
+         */
+        name: string | RegExp,
+        /**
+         * Provide the component to get the feature template from.
+         */
+        component: A_TYPES__FeatureAvailableComponents,
+        /**
+         * Provide the scope that dictates which components are active and can provide extensions for the feature.
+         */
+        scope: A_Scope
+    ): Array<A_TYPES__A_StageStep> {
+        // name for error messages
+        const componentName = (component as any)?.constructor?.name || String(component);
+
+        // Input validation
+        if (!component) throw new A_ContextError(A_ContextError.InvalidFeatureTemplateParameterError, `Unable to get feature template. Component cannot be null or undefined.`);
+        if (!name) throw new A_ContextError(A_ContextError.InvalidFeatureTemplateParameterError, `Unable to get feature template. Feature name cannot be null or undefined.`);
+
+        // Check if the parameter is allowed for feature definition
+        if (!A_TypeGuards.isAllowedForFeatureDefinition(component))
+            throw new A_ContextError(A_ContextError.InvalidFeatureTemplateParameterError, `Unable to get feature template. Component of type ${componentName} is not allowed for feature definition.`);
+
+        const steps: A_TYPES__A_StageStep[] = [
+            // 1) Get the base feature definition from the component
+            ...this.featureDefinition(name, component),
+            // 2) Get all extensions for the feature from other components in the scope
+            ...this.featureExtensions(name, component, scope)
+        ];
+
+        return steps;
+    }
+    // ----------------------------------------------------------------------------------------------------------
+    // -----------------------------------Helper Methods --------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------------------
     /**
-     * This method returns a component by its meta.
+     * Returns all extensions for the specific feature in the specific component within the provided scope.
+     * Scope dictates which components are active and can provide extensions for the feature.
+     * 
+     * [!] This method only returns extensions, not the base feature definition.
      * 
-     * @param meta 
+     * @param scope 
      * @returns 
      */
-    static component(
-        meta: A_ComponentMeta
-    ): typeof A_Component {
+    static featureExtensions(
+        /**
+         * Provide the name of the feature to get the template for. Regular expressions are also supported to match multiple features.
+         */
+        name: string | RegExp,
+        /**
+         * Provide the component to get the feature template from.
+         */
+        component: A_TYPES__FeatureAvailableComponents,
+        /**
+         * Provide the scope that dictates which components are active and can provide extensions for the feature.
+         */
+        scope: A_Scope
+    ): Array<A_TYPES__A_StageStep> {
+
         const instance = this.getInstance();
+        // name for error messages
+        const componentName = (component as any)?.constructor?.name || String(component);
 
-        let component: typeof A_Component | undefined;
+        // Input validation
+        if (!component) throw new A_ContextError(A_ContextError.InvalidFeatureExtensionParameterError, `Unable to get feature template. Component cannot be null or undefined.`);
+        if (!name) throw new A_ContextError(A_ContextError.InvalidFeatureExtensionParameterError, `Unable to get feature template. Feature name cannot be null or undefined.`);
 
-        instance.componentsMeta.forEach((meta, constructor) => {
-            if (meta === meta) {
-                component = constructor;
-            }
-        });
+        // Check if the parameter is allowed for feature definition
+        if (!A_TypeGuards.isAllowedForFeatureDefinition(component))
+            throw new A_ContextError(A_ContextError.InvalidFeatureExtensionParameterError, `Unable to get feature template. Component of type ${componentName} is not allowed for feature definition.`);
 
-        if (!component) {
-            throw new Error(`[!] A-Concept Context: Component not found.`);
-        }
-        return component;
-    }
+        const callName = `${component.constructor.name}.${name}`;
 
+        const steps: A_TYPES__A_StageStep[] = [];
 
+        // We need to get all components that has extensions for the feature in component
+        for (const [component, meta] of instance._metaStorage) {
+            // Just try to make sure that component not only Indexed but also presented in scope
+            if (scope.has(component) && A_TypeGuards.isComponentMetaInstance(meta))
+                // Get all extensions for the feature
+                meta
+                    .extensions(callName)
+                    .forEach((declaration) => {
+                        steps.push({
+                            component,
+                            ...declaration
+                        });
+                    });
+        }
+
+        return steps;
+    }
     /**
-     * This method returns a constructor params to create a new feature
+     * This method returns the feature template definition without any extensions.
+     * It can be used to retrieve the base template for a feature before any modifications are applied.
      * 
-     * @param scope 
+     * [!] This method does not consider extensions from other components.
+     * 
+     * @param feature 
+     * @param component 
      * @returns 
      */
     static featureDefinition(
-        component: A_Component | A_Container | A_Entity,
+        /**
+         * Name of the feature to get the template for.
+         * Regular expressions are also supported to match multiple features.
+         */
         feature: string | RegExp,
-        scope: A_Scope
-    ): A_TYPES__FeatureConstructor {
-        const instance = this.getInstance();
-
-        const name = `${component.constructor.name}.${feature}`;
-
-
-        /**
-         * Important NOTE::: Component Scope and Parent Scope are different things.
-         * 
-         * Component Scope is a scope where Component Registered. 
-         * Parent Scope is a scope From Where Feature Requested. 
-         * 
-         * 
-         * Example: ComponentA registered in ScopeA of ContainerA. 
-         * When FeatureA Requested from ContainerA, then Parent Scope is ScopeA For the FeatureA [!]
-         * BUT In FeatureA may be used ComponentB with FeatureB. 
-         * 
-         * 
-         * ------------------------------Execution-----------------------------------------------------------
-         * ContainerA      ->      FeatureA       ->    ComponentA     ->     FeatureB       ->     ComponentB
-         * - Scope:ScopeA  ->  - Scope:  FeatA    -> - Scope: ScopeA   -> - Scope:  FeatB    -> - Scope: ScopeA
-         *                     - Parent: ScopeA   -> - Parent: ROOT    -> - Parent: FeatA    -> - Parent: ROOT
-         * --------------------------------------------------------------------------------------------------
-         * 
-         * So ComponentA and ComponentB  are registered in the SAME scope of ContainerA.
-         * But Each Feature has its own Scope and Parent Scope.
-         * 
-         * 
-         * Component AND Entity DO [!] NOT HAVE THEIR OWN SCOPE.
-         * 
-         * Feature AND Container HAVE OWN SCOPE.
-         * 
-         * 
-         * So Parent can come from the Container or from the Feature.
-         * While Scope we use just to store the scope where the component registered.
-         *  
+        /**
+         * Component to get the feature template from.
          */
+        component: A_TYPES__FeatureAvailableComponents,
+    ): Array<A_TYPES__A_StageStep> {
         let metaKey;
 
+        if (!feature)
+            throw new A_ContextError(A_ContextError.InvalidFeatureTemplateParameterError, `Unable to get feature template. Feature name cannot be null or undefined.`);
+        if (!component)
+            throw new A_ContextError(A_ContextError.InvalidFeatureTemplateParameterError, `Unable to get feature template. Component cannot be null or undefined.`);
+
+
         switch (true) {
             case component instanceof A_Entity:
                 metaKey = A_TYPES__EntityMetaKey.FEATURES;
@@ -460,210 +698,208 @@ export class A_Context {
             case component instanceof A_Component:
                 metaKey = A_TYPES__ComponentMetaKey.FEATURES
                 break;
-            case component instanceof A_Command:
-                metaKey = A_TYPES__CommandMetaKey.FEATURES
-                break;
 
             default:
-                throw new Error(`A-Feature cannot be defined on the ${component} level`);
+                throw new A_ContextError(A_ContextError.InvalidFeatureTemplateParameterError, `A-Feature cannot be defined on the ${component} level`);
         }
 
-        const featureDefinition: A_TYPES__A_DefineDecorator_Meta | undefined = this
-            .meta(component)
+        const featureDefinition: A_TYPES__FeatureDefineDecoratorMeta | undefined = this.meta(component)
             ?.get(metaKey)
             ?.get(feature);
 
-
-        const steps: A_TYPES__A_StageStep[] = [
+        return [
             ...(featureDefinition?.template || [])
         ];
-        // const feature: string = new ASEID({
-        //     id: `${param2}-${Math.random()}`,
-        //     entity: 'a-feature',
-        //     namespace: component.constructor.name,
-        //     scope: scope.name
-        // }).toString();
-
-
-        // Now we need to resolve the method from all registered components 
-
-        // We need to get all components that has extensions for the feature in component
-        instance.componentsMeta
-            .forEach((meta, constructor) => {
-                // Just try to make sure that component not only Indexed but also presented in scope
-                if (scope.has(constructor))
-                    // Get all extensions for the feature
-                    meta
-                        .extensions(name)
-                        .forEach((declaration) => {
-                            steps.push({
-                                component: constructor,
-                                ...declaration
-                            });
-                        });
-            });
-
-
-
-        return { name, steps, scope, caller: component };
     }
 
+    // ==========================================================================================================
+    // ================================== ABSTRACTION MANAGEMENT =================================================
+    // ==========================================================================================================
+    // ----------------------------------------------------------------------------------------------------------
+    // -----------------------------------Primary Methods -------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------------------
     /**
-     * This method returns a constructor params to create a new feature
+     * Returns a definition of the abstraction that can be then used to create a new A-Feature Instance
      * 
-     * @param scope 
-     * @returns 
+     * [!] Note: Steps/Stages included are fully dependent on the scope provided since it dictates which components are active and can provide extensions for the abstraction.
+     * 
+     * @param abstraction 
      */
-    static abstractionDefinition(
-        component: A_Component | A_Container | A_Entity | A_Command,
-        abstraction: A_TYPES__ConceptStage,
+    static abstractionTemplate(
+        /**
+         * Provide the abstraction stage to get the definition for.
+         */
+        abstraction: A_TYPES__ConceptAbstraction,
+        /**
+         * Provide the component to get the abstraction definition from.
+         */
+        component: A_TYPES__FeatureAvailableComponents,
+        /**
+         * Provide the scope that dictates which components are active and can provide extensions for the abstraction.
+         */
         scope: A_Scope
-    ): A_TYPES__FeatureConstructor {
-        const instance = this.getInstance();
+    ): Array<A_TYPES__A_StageStep> {
+        // name for error messages
+        const componentName = (component as any)?.constructor?.name || String(component);
 
-        const name = `${component.constructor.name}.${abstraction}`;
-
-        let metaKey;
-
-        switch (true) {
-            case component instanceof A_Entity:
-                metaKey = A_TYPES__EntityMetaKey.FEATURES;
-                break;
-            case component instanceof A_Container:
-                metaKey = A_TYPES__ContainerMetaKey.ABSTRACTIONS
-                break;
-            case component instanceof A_Component:
-                metaKey = A_TYPES__ComponentMetaKey.ABSTRACTIONS
-                break;
-            case component instanceof A_Command:
-                metaKey = A_TYPES__CommandMetaKey.ABSTRACTIONS
-                break;
-            default:
-                throw new Error(`A-Feature cannot be defined on the ${component} level`);
-        }
+        // Input validation
+        if (!component) throw new A_ContextError(
+            A_ContextError.InvalidAbstractionTemplateParameterError,
+            `Unable to get feature template. Component cannot be null or undefined.`);
 
-        const featureDefinition = this.meta(component)
-            .get(metaKey)
-            .get(abstraction) || []
+        if (!abstraction) throw new A_ContextError(
+            A_ContextError.InvalidAbstractionTemplateParameterError,
+            `Unable to get feature template. Abstraction stage cannot be null or undefined.`);
 
+        // Check if the parameter is allowed for feature definition
+        if (!A_TypeGuards.isAllowedForAbstractionDefinition(component))
+            throw new A_ContextError(A_ContextError.InvalidAbstractionTemplateParameterError, `Unable to get feature template. Component of type ${componentName} is not allowed for feature definition.`);
 
         const steps: A_TYPES__A_StageStep[] = [
-            ...featureDefinition
-        ];
-
-
-        // We need to get all components that has extensions for the feature in component
-        instance.componentsMeta
-            .forEach((meta, constructor) => {
-                // Just try to make sure that component not only Indexed but also presented in scope
-                if (scope.has(constructor))
-                    // Get all extensions for the feature
-                    meta
-                        .abstractions(name)
-                        .forEach((declaration) => {
-                            steps.push({
-                                component: constructor,
-                                ...declaration
-                            });
-                        });
-            });
+            // 1) Get the base abstraction definition from the component
+            // [!] No abstraction Definitions -> They are limited to Concept Abstractions ONLY
+            // ...this.abstractionDefinition(abstraction, component),
 
+            // 2) Get all extensions for the abstraction from other components in the scope
+            ...this.abstractionExtensions(abstraction, component, scope)
+        ];
 
-        return { name, steps, scope, caller: component };
+        return steps;
     }
 
-    /**
-     * This method returns a step-by-step instructions of feature implementation depending on the feature name and the class.
-     * 
-     * @param scope 
-     * @returns 
-     */
-    static feature<T extends Array<string>>(
-        component: A_Component | A_Container | A_Entity<any, any>,
-        feature: string | T[number] | RegExp,
+    // ----------------------------------------------------------------------------------------------------------
+    // -----------------------------------Helper Methods --------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------------------
+
+    static abstractionExtensions(
+        /**
+         * Provide the abstraction name to get the definition for.
+         */
+        abstraction: A_TYPES__ConceptAbstraction,
+        /**
+         * Provide the component to get the abstraction definition from.
+         */
+        component: A_TYPES__FeatureAvailableComponents,
+        /**
+         * Provide the scope that dictates which components are active and can provide extensions for the abstraction.
+         */
         scope: A_Scope
-    ): A_Feature {
-        const featureConstructor = this.featureDefinition(component, feature, scope);
+    ): Array<A_TYPES__A_StageStep> {
+        const instance = this.getInstance();
+        // name for error messages
+        const componentName = (component as any)?.constructor?.name || String(component);
+
+        // Input validation
+        if (!component) throw new A_ContextError(
+            A_ContextError.InvalidAbstractionExtensionParameterError,
+            `Unable to get feature template. Component cannot be null or undefined.`
+        );
+        if (!abstraction) throw new A_ContextError(
+            A_ContextError.InvalidAbstractionExtensionParameterError,
+            `Unable to get feature template. Abstraction stage cannot be null or undefined.`
+        );
+        // Check if the parameter is allowed for feature definition
+        if (!A_TypeGuards.isAllowedForAbstractionDefinition(component))
+            throw new A_ContextError
+                (A_ContextError.InvalidAbstractionExtensionParameterError,
+                    `Unable to get feature template. Component of type ${componentName} is not allowed for feature definition.`
+                );
+
+        const callName = `${component.constructor.name}.${abstraction}`;
+
+        const steps: A_TYPES__A_StageStep[] = [];
 
-        const newFeature = new A_Feature(featureConstructor);
+        // We need to get all components that has extensions for the feature in component
+        for (const [component, meta] of instance._metaStorage) {
+            // Just try to make sure that component not only Indexed but also presented in scope
+            if (scope.has(component) && A_TypeGuards.isComponentMetaInstance(meta))
+                // Get all extensions for the feature
+                meta
+                    .abstractions(callName)
+                    .forEach((declaration) => {
+                        steps.push({
+                            component,
+                            ...declaration
+                        });
+                    });
+        }
 
-        return newFeature;
+        return steps;
     }
 
 
 
     /**
-     * Register a Namespace in the provider.
-     * @param Namespace 
+     * Resets the Context to its initial state.
      */
-    static register(
-        scope: A_Scope,
-        container: A_Container
-    )
-    static register(
-        scope: A_Scope,
-        entity: A_Entity
-    )
-    static register(
-        scope: A_Scope,
-        component: A_Component
-    )
-    static register(
-        scope: A_Scope,
-        fragment: A_Fragment
-    )
-    static register(
-        scope: A_Scope,
-        param1: A_Fragment | A_Container | A_Entity | A_Component
-    ) {
-        const instance = this.getInstance();
+    static reset() {
+        const instance = A_Context.getInstance();
 
-        // if (!instance._root)
-        //     instance._root = scope.name;
+        instance._registry = new WeakMap();
+        instance._metaStorage = new Map();
 
-        switch (true) {
-            case param1 instanceof A_Component:
-                instance.registry.set(param1, scope);
-                break;
+        let name = 'root';
 
-            case param1 instanceof A_Container:
-                instance.registry.set(param1, scope);
-                break;
+        if (A_Context.environment === 'server')
+            name = process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] || 'root';
 
-            case param1 instanceof A_Entity:
-                instance.registry.set(param1, scope);
-                break;
+        if (A_Context.environment === 'browser')
+            name = (window as any)[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] || 'root';
 
-            case param1 instanceof A_Fragment && !instance.registry.has(param1):
-                instance.registry.set(param1, scope);
-                break;
+        instance._root = new A_Scope({ name });
+    }
 
-            default:
-                if (!instance.registry.has(param1))
-                    instance.registry.set(param1, scope);
 
-                break;
-        }
-    }
 
 
+    // ====================================================================================================================
+    // ====================================== HELPERS & GUARDS ============================================================
+    // ====================================================================================================================
     /**
-     * Resets the Context to its initial state.
+     * Type guard to check if the param is allowed for scope allocation.
+     * 
+     * @param param 
+     * @returns 
      */
-    static reset() {
-        const instance = A_Context.getInstance();
+    static isAllowedForScopeAllocation(param: any): param is A_TYPES__ScopeLinkedComponents {
+        return A_TypeGuards.isContainerInstance(param)
+            || A_TypeGuards.isFeatureInstance(param);
+    }
+    /**
+     * Type guard to check if the param is allowed to be registered in the context.
+     * 
+     * @param param 
+     * @returns 
+     */
+    static isAllowedToBeRegistered(param: any): param is A_TYPES_ScopeDependentComponents {
+        return A_TypeGuards.isEntityInstance(param)
+            || A_TypeGuards.isComponentInstance(param)
+            || A_TypeGuards.isFragmentInstance(param);
+    }
+
+    /**
+     * Type guard to check if the param is allowed for meta storage.
+     * 
+     * @param param 
+     * @returns 
+     */
+    static isAllowedForMeta(param: any): param is A_TYPES__MetaLinkedComponents {
+        return A_TypeGuards.isContainerInstance(param)
+            || A_TypeGuards.isComponentInstance(param)
+            || A_TypeGuards.isEntityInstance(param);
+    }
+    /**
+     * Type guard to check if the param is allowed for meta storage by constructor.
+     * 
+     * @param param 
+     * @returns 
+     */
+    static isAllowedForMetaConstructor(param: any): param is A_TYPES__MetaLinkedComponentConstructors {
+        return A_TypeGuards.isContainerConstructor(param)
+            || A_TypeGuards.isComponentConstructor(param)
+            || A_TypeGuards.isEntityConstructor(param);
+    }
 
-        instance.containers = new WeakMap();
-        instance.features = new WeakMap();
-        instance.registry = new WeakMap();
-        instance.containersMeta = new Map();
-        instance.componentsMeta = new Map();
-        instance.entitiesMeta = new Map();
-        instance.customMeta = new Map();
 
-        instance._root = new A_Scope({
-            name: process && process.env ? process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE] || 'a-concept' : 'a-concept'
-        });
 
-    }
 }