@adaas/a-concept 0.0.63 → 0.0.64

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

@@ -1,112 +1,218 @@
-import { A_CommonHelper, ASEID } from "@adaas/a-utils";
-import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "./A-Scope.types";
-import { A_Fragment } from "../A-Fragment/A-Fragment.class";
-import { A_Context } from "../A-Context/A-Context.class";
 import {
-    A_TYPES__ComponentMetaKey
-} from "../A-Component/A-Component.types";
-import { A_Component } from "../A-Component/A-Component.class";
-import { A_Entity } from "../A-Entity/A-Entity.class";
+    A_CommonHelper,
+    A_Error,
+    ASEID
+} from "@adaas/a-utils";
+import {
+    A_TYPES__AllowedCommandsConstructor,
+    A_TYPES__AllowedComponentsConstructor,
+    A_TYPES__AllowedEntitiesConstructor,
+    A_TYPES__AllowedFragmentsConstructor,
+    A_TYPES__AllowedScopesConstructor,
+    A_TYPES__ScopeConfig,
+    A_TYPES__ScopeConstructor
+} from './A-Scope.types'
 import {
     A_TYPES__A_InjectDecorator_EntityInjectionInstructions,
     A_TYPES__A_InjectDecorator_EntityInjectionQuery,
-    A_TYPES__A_InjectDecorator_Injectable
 } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
+import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.types";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_Context } from "../A-Context/A-Context.class";
+import { A_Component } from "../A-Component/A-Component.class";
+import { A_Entity } from "../A-Entity/A-Entity.class";
 import { A_Command } from "../A-Command/A-Command.class";
 
 
-/**
- * 
- * 
- * A_Scope refers to the visibility and accessibility of :
- * - variables, 
- * - Components, 
- * - Context Fragments 
- * - and objects in different parts of your code. 
- * Scope determines where a particular piece of data (like a variable or function) 
- * can be accessed, modified, or referenced, and it plays a crucial role in avoiding naming collisions and ensuring data integrity. 
- * 
- * 
- */
-export class A_Scope {
 
+
+export class A_Scope<
+    _ComponentType extends A_TYPES__AllowedComponentsConstructor[] = A_TYPES__AllowedComponentsConstructor[],
+    _CommandType extends A_TYPES__AllowedCommandsConstructor[] = A_TYPES__AllowedCommandsConstructor[],
+    _EntityType extends A_Entity[] = A_Entity[],
+    _FragmentType extends A_Fragment[] = A_Fragment[],
+> {
+
+    /**
+     * Scope Name uses for identification and logging purposes
+     */
     readonly name: string = '';
+    /**
+     * Parent scope reference, used for inheritance of components, fragments, entities and commands
+     */
+    protected _parent?: A_Scope;
 
-    private _components: WeakMap<typeof A_Component.constructor, any> = new WeakMap();
-    private _fragments: WeakMap<typeof A_Fragment.constructor, any> = new WeakMap();
-    private _commands: Map<string, A_Command> = new Map();
-    private _entities: Map<string, A_Entity> = new Map();
+    // ===========================================================================
+    // --------------------ALLowed Constructors--------------------------------
+    // ===========================================================================
+    /**
+     * A set of allowed components, A set of constructors that are allowed in the scope
+     *      
+     */
+    protected _allowedComponents = new Set<_ComponentType[number]>();
+    /**
+     * A set of allowed entities, A set of constructors that are allowed in the scope
+     */
+    protected _allowedEntities = new Set<A_TYPES__AllowedEntitiesConstructor<_EntityType[number]>>();
+    /**
+     * A set of allowed fragments, A set of constructors that are allowed in the scope
+     */
+    protected _allowedFragments = new Set<A_TYPES__AllowedFragmentsConstructor<_FragmentType[number]>>();
+    /**
+     * A set of allowed commands, A set of constructors that are allowed in the scope
+     */
+    protected _allowedCommands = new Set<_CommandType[number]>();
 
-    private _parent?: A_Scope;
 
-    protected params!: A_TYPES__ScopeConstructor
+    // ===========================================================================
+    // --------------------Internal Storage--------------------------------
+    // ===========================================================================
+    /**
+     * Internal storage for the components, fragments, entities and commands
+     */
+    protected _components: Map<_ComponentType[number], InstanceType<_ComponentType[number]>> = new Map();
+    /**
+     * Storage for the fragments, should be weak as fragments are singletons per scope
+     */
+    protected _fragments: Map<A_TYPES__AllowedFragmentsConstructor<_FragmentType[number]>, _FragmentType[number]> = new Map();
+    /**
+     * Storage for the entities, should be strong as entities are unique per aseid
+     */
+    protected _entities: Map<string, _EntityType[number]> = new Map();
+    /**
+     * Storage for the commands, should be strong as commands are unique per code
+     */
+    protected _commands: Map<string, InstanceType<_CommandType[number]>> = new Map();
 
 
-    constructor(
-        params: Partial<A_TYPES__ScopeConstructor>,
-        config: Partial<A_TYPES__ScopeConfig> = {}
-    ) {
-        this.name = params.name || this.constructor.name;
 
-        // TODO: move to defaults
-        const defaultParams: A_TYPES__ScopeConstructor = {
-            name: '',
-            components: [],
-            fragments: [],
-            entities: [],
-            commands: [],
-        };
+    // ===========================================================================
+    // --------------------Readonly Allowed Properties----------------------------
+    // ===========================================================================
+    /**
+     * Returns a list of Constructors for A-Components that are available in the scope
+     */
+    get allowedComponents() { return this._allowedComponents }
+    /**
+     * Returns a list of Constructors for A-Commands that are available in the scope
+     */
+    get allowedCommands() { return this._allowedCommands }
+    /**
+     * Returns a list of Constructors for A-Fragments that are available in the scope
+     */
+    get allowedFragments() { return this._allowedFragments }
+    /**
+     * Returns a list of Constructors for A-Entities that are available in the scope
+     */
+    get allowedEntities() { return this._allowedEntities }
 
+    /**
+     * Returns an Array of entities registered in the scope
+     * 
+     * [!] One entity per aseid
+     */
+    get entities(): Array<_EntityType[number]> { return Array.from(this._entities.values()) }
+    /**
+     * Returns an Array of fragments registered in the scope
+     * 
+     * [!] One fragment per scope
+     */
+    get fragments(): Array<_FragmentType[number]> { return Array.from(this._fragments.values()) }
+    /**
+     * Returns an Array of components registered in the scope
+     * 
+     * [!] One component instance per scope
+     */
+    get components(): Array<InstanceType<_ComponentType[number]>> { return Array.from(this._components.values()) }
+    /**
+     * Returns an Array of commands registered in the scope
+     * 
+     * [!] One command per command aseid
+     * [!!] There may be any number of instances of the same command code, but with different aseids. 
+     */
+    get commands(): Array<InstanceType<_CommandType[number]>> { return Array.from(this._commands.values()) }
 
-        this.params = {
-            ...defaultParams,
-            ...params
-        }
 
-        this.initComponents(params.components || []);
-        this.initFragments(params.fragments || []);
-        this.initEntities(params.entities || []);
+    /**
+     * A_Scope refers to the visibility and accessibility of :
+     * - variables, 
+     * - Components, 
+     * - Context Fragments 
+     * - Commands
+     * - Entities
+     * - and objects in different parts of your code. 
+     * Scope determines where a particular piece of data (like a variable or function) 
+     * can be accessed, modified, or referenced, and it plays a crucial role in avoiding naming collisions and ensuring data integrity. 
+     * 
+     * [!] The scope behavior is similar to tree structure where each scope can have a parent scope and inherit its components, fragments, entities and commands
+     * 
+     * @param params 
+     * @param config 
+     */
+    constructor(
+        params: Partial<A_TYPES__ScopeConstructor<_ComponentType, _CommandType, _EntityType, _FragmentType>>,
+        config: Partial<A_TYPES__ScopeConfig> = {}
+    ) {
+        this.name = params.name || this.constructor.name
+
+        this.initComponents(params.components);
+        this.initCommands(params.commands);
+        this.initFragments(params.fragments);
+        this.initEntities(params.entities);
 
         if (config.parent) {
             this._parent = config.parent;
         }
     }
 
+    //==========================================================================
+    // --------------------Scope Initialization Methods---------------------------
+    //==========================================================================
 
-    private initComponents(_components: Array<{ new(...args: any[]): any }>) {
-        // _components.forEach(component => {
-        //     this._components.set(component, new component());
-        // })
-    }
-
-    private initEntities(_entities: Array<A_Entity>) {
-        _entities.forEach(this.register.bind(this));
-    }
-
-
-    private initFragments(_fragments: Array<A_Fragment>) {
-        _fragments.forEach(this.register.bind(this));
-    }
-
-
-    get components() {
-        return this.params.components || [];
-    }
-
-    get commands() {
-        return this.params.commands || [];
-    }
-
-    get fragments() {
-        return this.params.fragments || [];
-    }
+    /**
+     * This method is used to initialize the components in the scope
+     * To save memory components are initialized only when they are requested
+     * 
+     * This method only registers the component in the scope in case they are not registered yet
+     * 
+     * @param _components 
+     */
+    protected initComponents(_components?: _ComponentType) { _components?.forEach(this.register.bind(this)); }
+    /**
+     * This method is used to initialize the entities in the scope
+     * 
+     * This method only registers the entities in the scope in case they are not registered yet
+     * 
+     * @param _entities 
+     */
+    protected initEntities(_entities?: _EntityType) { _entities?.forEach(this.register.bind(this)); }
+    /**
+     * This method is used to initialize the fragments in the scope
+     * 
+     * This method only registers the fragments in the scope in case they are not registered yet
+     * 
+     * @param _fragments 
+     */
+    protected initFragments(_fragments?: _FragmentType) { _fragments?.forEach(this.register.bind(this)); }
+    /**
+     * This method is used to initialize the commands in the scope
+     * 
+     * This method only registers the commands in the scope in case they are not registered yet
+     * 
+     * @param _commands 
+     */
+    protected initCommands(_commands?: _CommandType) { _commands?.forEach(this.register.bind(this)); }
 
 
-    parent(setValue: A_Scope): void
-    parent(): A_Scope
-    parent(
-        setValue?: A_Scope
-    ): A_Scope | undefined {
+    /**
+     * This method is used to get or set the parent scope
+     * 
+     * [!] Note that setting the parent scope will override the existing parent scope
+     * 
+     * @param setValue 
+     * @returns 
+     */
+    parent(setValue?: A_Scope): A_Scope | undefined {
         if (setValue) {
             return this.inherit(setValue);
         }
@@ -114,162 +220,131 @@ export class A_Scope {
         return this._parent;
     }
 
-    isInheritedFrom(scope: A_Scope): boolean {
-        let current: A_Scope | undefined = this;
-
-        while (current) {
-            if (current === scope) {
-                return true;
-            }
-            current = current._parent;
-        }
-
-        return false;
-    }
-
-
-    inherit(parent: A_Scope): A_Scope {
-        // Prevent circular inheritance
-        const circularCheck = this.checkCircularInheritance(parent);
-
-        if (circularCheck) {
-            throw new Error(`Circular inheritance detected: ${[...circularCheck, parent.name].join(' -> ')}`);
-        }
-
-        this._parent = parent;
-        return this;
-    }
-
 
 
     /**
-     * Helper method to check circular inheritance
-     * Should return a full sequence of inheritance for logging purposes
+     * This method is used to inherit from a parent scope
      * 
-     * @param scope 
+     * [!] This method checks for circular inheritance and throws an error if detected
+     * 
+     * @param parent 
      * @returns 
      */
-    checkCircularInheritance(scope: A_Scope): Array<string> | false {
-        const inheritanceChain: Array<string> = [];
-        let current: A_Scope | undefined = this._parent;
-
-        while (current) {
-            inheritanceChain.push(current.name);
-            if (current === scope) {
-                return inheritanceChain;
-            }
-            current = current._parent;
-        }
-
-        return false;
-    }
-
+    inherit(parent: A_Scope): A_Scope {
+        // Prevent circular inheritance
+        const circularCheck = this.checkCircularInheritance(parent);
 
-    printInheritanceChain(): void {
-        const chain: Array<string> = [];
-        let current: A_Scope | undefined = this;
+        if (circularCheck)
+            throw new A_Error(`Circular inheritance detected: ${[...circularCheck, parent.name].join(' -> ')}`);
 
-        while (current) {
-            chain.push(current.name);
-            current = current._parent;
-        }
 
-        console.log(chain.join(' -> '));
+        this._parent = parent;
+        return this;
     }
 
 
     /**
      * This method is used to check if the component is available in the scope
      * 
+     * [!] Note that this method checks for the component in the current scope and all parent scopes
+     * 
      * @param component 
      * @returns 
      */
     has<T extends A_Component>(
-        component: new (...args: any[]) => T
+        /**
+         * Provide a component constructor to check if it's available in the scope
+         */
+        component: A_TYPES__AllowedComponentsConstructor<T>
     ): boolean
     has<T extends A_Entity>(
-        entity: new (...args: any[]) => T
+        /**
+         * Provide an entity constructor to check if it's available in the scope
+         * 
+         * [!] Note that entities are unique per aseid, so this method checks if there's at least one entity of the provided type in the scope
+         */
+        entity: A_TYPES__AllowedEntitiesConstructor<T>
     ): boolean
     has<T extends A_Fragment>(
-        fragment: new (...args: any[]) => T
+        /**
+         * Provide a fragment constructor to check if it's available in the scope
+         */
+        fragment: A_TYPES__AllowedFragmentsConstructor<T>
+    ): boolean
+    has<T extends A_Fragment>(
+        /**
+         * Provide a command constructor to check if it's available in the scope
+         */
+        command: A_TYPES__AllowedCommandsConstructor<T>
     ): boolean
     has(
+        /**
+         * Provide a string to check if a component, entity or fragment with the provided name is available in the scope
+         */
         constructor: string
     ): boolean
-    has<T extends A_Fragment | A_Component | A_Entity | A_Command>(
-        entity: T | string | (new (...args: any[]) => T)
+    has(
+        ctor: unknown
     ): boolean {
 
+        let found = false;
 
         switch (true) {
+            // 1) Check by string name.  
+            case typeof ctor === 'string': {
+                // 1.1 Check if it's a component name
+                const possibleComponent = Array.from(this.allowedComponents).find(c => c.name === ctor);
+                if (possibleComponent) found = true;
 
-            case typeof entity === 'string': {
-                const possibleComponent = this.params.components.find(c => c.name === entity);
+                // 1.2 Check if it's a fragment name
+                const possibleFragment = Array.from(this.allowedFragments).find(f => f.name === ctor);
+                if (possibleFragment) found = true;
 
-                if (possibleComponent) {
-                    return true;
-                }
+                // 1.3 Check if it's a command code or name
+                const possibleCommand = Array.from(this.allowedCommands).find(c => c.name === ctor);
+                if (possibleCommand) found = true;
 
-                const possibleFragment = this.params.fragments.find(f => f.name === entity);
-
-                if (possibleFragment) {
-                    return true;
-                }
-
-                if (this.params.entities.some(e => e.constructor.name === entity)) {
-                    return true;
-                }
+                // 1.4 Check if it's an entity name or entity static entity property
+                const possibleEntity = Array.from(this.allowedEntities).find(e => e.name === ctor);
+                if (possibleEntity) found = true;
 
+                // 1.5 If not found in current scope, check parent scope
                 if (!!this._parent)
-                    return this._parent.has(entity);
+                    return this._parent.has(ctor);
 
                 return false;
             }
+            // 2) Check if it's a Component
+            case this.isComponentConstructor(ctor): {
+                found = this.isAllowedComponent(ctor);
 
-            case typeof entity === 'function'
-                && A_CommonHelper.isInheritedFrom(entity, A_Component): {
-                    const found = this.components.includes(entity as { new(...args: any[]): A_Component });
-
-                    if (!found && !!this._parent) {
-                        return this._parent.has(entity as any);
-                    }
-
-                    return found;
-                }
-
-            case typeof entity === 'function'
-                && A_CommonHelper.isInheritedFrom(entity, A_Entity): {
-                    const entities = Array.from(this._entities.values());
-
-                    const found = entities.find(e => e instanceof entity);
-
-                    return !!found;
-                }
-
-            case typeof entity === 'function'
-                && A_CommonHelper.isInheritedFrom(entity, A_Fragment): {
-                    const found = this._fragments.has(entity);
+                break;
+            }
+            // 3) Check if it's an Entity
+            case this.isEntityConstructor(ctor): {
+                found = this.isAllowedEntity(ctor);
 
-                    if (!found && !!this._parent)
-                        return this._parent.has(entity as any);
+                break;
+            }
+            // 4) Check if it's a Fragment
+            case this.isFragmentConstructor(ctor): {
+                found = this.isAllowedFragment(ctor);
 
-                    return found;
-                }
-            case typeof entity === 'function'
-                && A_CommonHelper.isInheritedFrom(entity, A_Command): {
-                    const found = this.commands.includes(entity as { new(...args: any[]): A_Command });
+                break;
+            }
+            // 5) Check if it's a Command
+            case this.isCommandConstructor(ctor): {
+                found = this.isAllowedCommand(ctor);
 
-                    if (!found && !!this._parent)
-                        return this._parent.has(entity as any);
+                break;
+            }
+        }
 
-                    return found;
-                }
+        if (!found && !!this._parent)
+            return this._parent.has(ctor as any);
 
 
-            default: {
-                return false;
-            }
-        }
+        return found;
     }
 
 
@@ -286,19 +361,13 @@ export class A_Scope {
     merge(anotherScope: A_Scope): A_Scope {
         const merged = new A_Scope(
             {
-                name: `${this.name}&${anotherScope.name}`,
-                components: Array.from(new Set([
-                    ...this.params.components,
-                    ...anotherScope.params.components
-                ])),
-                fragments: Array.from(new Set([
-                    ...this.params.fragments,
-                    ...anotherScope.params.fragments
-                ])),
-                entities: Array.from(new Set([
-                    ...this.params.entities,
-                    ...anotherScope.params.entities
-                ])),
+                name: `${this.name} + ${anotherScope.name}`,
+
+                components: [...this.allowedComponents, ...anotherScope.allowedComponents],
+                commands: [...this.allowedCommands, ...anotherScope.allowedCommands],
+
+                fragments: [...this.fragments, ...anotherScope.fragments],
+                entities: [...this.entities, ...anotherScope.entities],
             },
             {
                 parent: this._parent || anotherScope._parent
@@ -320,28 +389,63 @@ export class A_Scope {
      * @param name 
      * @returns 
      */
-    resolveConstructor<T extends A_Component | A_Entity>(name: string): new (...args: any[]) => T {
-        // Check components
-        const component = this.params.components.find(c => c.name === A_CommonHelper.toPascalCase(name));
-        if (component) return component as any;
-
-        // Check entities
-        const entity = this.params.entities.find(e => (e.constructor as any).entity === name
-            || (e.constructor as any).name === A_CommonHelper.toPascalCase(name)
-            || (e.constructor as any).entity === A_CommonHelper.toKebabCase(name)
+    resolveConstructor<T extends A_Command>(
+        /**
+         * Provide the command name or code to retrieve its constructor
+         */
+        name: string
+    ): A_TYPES__AllowedCommandsConstructor<T>
+    resolveConstructor<T extends A_Entity>(
+        /**
+         * Provide the entity name or static entity property to retrieve its constructor
+         */
+        name: string
+    ): A_TYPES__AllowedEntitiesConstructor<T>
+    resolveConstructor<T extends A_Component>(
+        /**
+         * Provide the component name in PascalCase to retrieve its constructor
+         */
+        name: string
+    ): A_TYPES__AllowedComponentsConstructor<T>
+    resolveConstructor<T extends A_Fragment>(
+        /**
+         * Provide the fragment name in PascalCase to retrieve its constructor
+         */
+        name: string
+    ): A_TYPES__AllowedFragmentsConstructor<T>
+    resolveConstructor<T extends A_Command | A_Entity | A_Component | A_Fragment>(name: string): A_TYPES__AllowedCommandsConstructor<T> | A_TYPES__AllowedEntitiesConstructor<T> | A_TYPES__AllowedComponentsConstructor<T> | A_TYPES__AllowedFragmentsConstructor<T> {
+        // 1) Check components
+        const component = Array.from(this.allowedComponents).find(
+            c => c.name === name
+                || c.name === A_CommonHelper.toPascalCase(name)
+        );
+        if (component) return component as A_TYPES__AllowedComponentsConstructor<T>;
+
+        // 2) Check entities
+        const entity = Array.from(this.allowedEntities).find(
+            e => e.name === name
+                || e.name === A_CommonHelper.toPascalCase(name)
+                || (e as any).entity === name
+                || (e as any).entity === A_CommonHelper.toKebabCase(name)
         );
-        if (entity) return entity.constructor as any;
+        if (entity) return entity as A_TYPES__AllowedEntitiesConstructor<T>;
 
-        // Check commands 
-        const command = this.params.commands.find(c => (c as any).code === name
+        // 3) Check commands
+        const command = Array.from(this.allowedCommands).find(c => (c as any).code === name
             || (c as any).name === A_CommonHelper.toPascalCase(name)
             || (c as any).code === A_CommonHelper.toKebabCase(name)
         );
-        if (command) return command as any;
+        if (command) return command as A_TYPES__AllowedCommandsConstructor<T>;
+
+        // 4) Check fragments
+        const fragment = Array.from(this.allowedFragments).find(f => f.name === name
+            || f.name === A_CommonHelper.toPascalCase(name)
+        );
+        if (fragment) return fragment as A_TYPES__AllowedFragmentsConstructor<T>;
 
         // If not found in current scope, check parent scope
         if (!!this._parent) {
-            return this._parent.resolveConstructor(name);
+            return this._parent.resolveConstructor(name) as any;
         }
 
         throw new Error(`Component or Entity with name ${name} not found in the scope ${this.name}`);
@@ -349,135 +453,219 @@ export class A_Scope {
 
 
 
-
-
     /**
-     * This method is used to get the component by class
+     * This method allows to resolve/inject a component, fragment or entity from the scope
+     * Depending on the provided parameters it can resolve:
+     * - A single component/fragment/entity by its constructor or name
+     * - An array of components/fragments/entities by providing an array of constructors
+     * - An entity or an array of entities by providing the entity constructor and query instructions
      * 
      * @param component 
      * @returns 
      */
-    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
-        string: string
-    ): InstanceType<T>
-    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
-        component: T
-    ): InstanceType<T>
+    resolve<T extends A_Component>(
+        /**
+         * Provide a component constructor to resolve its instance from the scope
+         */
+        component: A_TYPES__AllowedComponentsConstructor<T>
+    ): T
+    resolve<T extends A_TYPES__AllowedComponentsConstructor[]>(
+        /**
+         * Provide an array of component constructors to resolve their instances from the scope
+         */
+        components: [...T]
+    ): Array<InstanceType<T[number]>>
+    resolve<T extends A_Fragment>(
+        /**
+         * Provide a fragment constructor to resolve its instance from the scope
+         */
+        fragment: A_TYPES__AllowedFragmentsConstructor<T>
+    ): T
+    resolve<T extends A_TYPES__AllowedFragmentsConstructor[]>(
+        /**
+         * Provide an array of fragment constructors to resolve their instances from the scope
+         */
+        fragments: [...T]
+    ): Array<InstanceType<T[number]>>
+    resolve<T extends A_Command>(
+        /**
+         * Provide a command constructor to resolve its instance from the scope
+         */
+        command: A_TYPES__AllowedCommandsConstructor<T>
+    ): T
+    resolve<T extends A_TYPES__AllowedCommandsConstructor[]>(
+        /**
+         * Provide an array of command constructors to resolve their instances from the scope
+         */
+        commands: [...T]
+    ): Array<InstanceType<T[number]>>
+    resolve<T extends A_Entity>(
+        /**
+         * Provide an entity constructor to resolve its instance or an array of instances from the scope
+         */
+        entity: A_TYPES__AllowedEntitiesConstructor<T>
+    ): T | undefined
+    resolve<T extends A_Scope>(
+        /**
+         * Uses only in case of resolving a single entity
+         * 
+         * Provide an entity constructor to resolve its instance from the scope
+         */
+        scope: new (...args: any[]) => T
+    ): T
     resolve<T extends A_Entity>(
-        entity: { new(...args: any[]): T },
+        /**
+         * Provide an entity constructor to resolve its instance or an array of instances from the scope
+         */
+        entity: A_TYPES__AllowedEntitiesConstructor<T>,
+        /**
+         * Provide optional instructions to find a specific entity or a set of entities
+         */
         instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>
-    ): T | Array<T>
-    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
-        component: Array<T>
-    ): Array<InstanceType<T>>
+    ): Array<T>
     // base definition
-    resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
-        param1: Array<T> | T | string,
-        param2?: string | Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
-    ): Array<InstanceType<T>> | InstanceType<T> {
-
-
+    resolve<T extends A_Component | A_Fragment | A_Entity | A_Command>(
+        /**
+         * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
+         */
+        param1: unknown,
+        param2?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
+    ): T | Array<T> {
         switch (true) {
             case Array.isArray(param1): {
-                return param1.map(c => this.resolveOnce(param1 as any, param2 as any));
+                return param1.map(c => this.resolveOnce(c, param2)).filter(Boolean) as Array<T>;
             }
 
             case typeof param1 === 'function': {
-                return this.resolveOnce(param1 as any, param2 as any);
+                return this.resolveOnce(param1, param2);
             }
 
+
             case typeof param1 === 'string': {
-                return this.resolveByName(param1 as any) as InstanceType<T>;
+                return this.resolveByName(param1) as T;
             }
 
             default: {
-                throw new Error('Invalid arguments provided');
+                throw new A_Error(`Invalid parameter provided to resolve method: ${param1} in scope ${this.name}`);
             }
         }
     }
 
 
-    private resolveByName(name: string): A_Entity | A_Fragment | A_Component {
-        // Check components
-        const component = this.params.components.find(c => c.name === name);
-        if (component) return this.resolveComponent(component);
 
-        // Check commands
-        const command = this.params.commands.find(c => c.name === name);
-        if (command) return this.resolveComponent(command);
 
-        // Check fragments
-        const fragment = this.params.fragments.find(f => f.constructor.name === name);
-        if (fragment) return this.resolveFragment(fragment.constructor as any);
+    // ==================================================================================================
+    // --------------------------------------------------------------------------------------------------
+    // -------------------------------------INTERNAL RESOLVERS-------------------------------------------
+    // --------------------------------------------------------------------------------------------------
+    // ==================================================================================================
+    private resolveByName(name: string): _EntityType[number] | InstanceType<_ComponentType[number]> | _FragmentType[number] | InstanceType<_CommandType[number]> {
+        // 1) Check components
+        const component = Array.from(this.allowedComponents).find(
+            c => c.name === name
+                || c.name === A_CommonHelper.toPascalCase(name)
+        );
+        if (component) return this.resolveOnce(component) as InstanceType<_ComponentType[number]>;
+
+        // 2) Check entities
+        const entity = Array.from(this.allowedEntities).find(
+            e => e.name === name
+                || e.name === A_CommonHelper.toPascalCase(name)
+                || (e as any).entity === name
+                || (e as any).entity === A_CommonHelper.toKebabCase(name)
+        );
+        if (entity) return this.resolveOnce(entity) as _EntityType[number];
+
+        // 3) Check commands
+        const command = Array.from(this.allowedCommands).find(c => (c as any).code === name
+            || (c as any).name === A_CommonHelper.toPascalCase(name)
+            || (c as any).code === A_CommonHelper.toKebabCase(name)
+        );
+        if (command) return this.resolveOnce(command) as InstanceType<_CommandType[number]>;
 
-        // Check entities
-        const entity = this.params.entities.find(e => e.constructor.name === name);
-        if (entity) return this.resolveEntity(entity.constructor as any);
+        // 4) Check fragments
+        const fragment = Array.from(this.allowedFragments).find(f => f.name === name
+            || f.name === A_CommonHelper.toPascalCase(name)
+        );
+        if (fragment) return this.resolveOnce(fragment) as _FragmentType[number];
 
         // If not found in current scope, check parent scope
-        if (this._parent) {
-            return this._parent.resolveByName(name);
+        if (!!this._parent) {
+            return this._parent.resolveByName(name) as any;
         }
 
-        throw new Error(`Component, Fragment, or Entity with name ${name} not found in the scope ${this.name}`);
+        throw new Error(`Component or Entity with name ${name} not found in the scope ${this.name}`);
     }
 
-
-
-
-    private resolveOnce<T extends { new(...args: any[]): A_Entity }>(
-        entity: T,
-        instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
-    ): InstanceType<T> | undefined
-    private resolveOnce<T extends A_TYPES__A_InjectDecorator_Injectable>(
-        component: T
-    ): InstanceType<T>
-    private resolveOnce<T extends { new(...args: any[]): A_Entity } | A_TYPES__A_InjectDecorator_Injectable>(
-        component: T,
+    /**
+     * This method is used internally to resolve a single component, fragment or entity from the scope
+     * 
+     * @param component 
+     * @param instructions 
+     * @returns 
+     */
+    private resolveOnce<T extends A_Component | A_Fragment | A_Entity | A_Command | A_Scope>(
+        component: unknown,
         instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
-    ): InstanceType<T> {
+    ): T | Array<T> {
 
+        if (this.isScopeConstructor(component))
+            component
+
+        if (typeof component == 'function' && (component as any).name === 'A_Scope')
+            component
 
         switch (true) {
-            case A_CommonHelper.isInheritedFrom(component, A_Entity): {
-                return this.resolveEntity(component as any, instructions) as InstanceType<T>;
+            case this.isEntityConstructor(component): {
+                return this.resolveEntity(component, instructions) as T | Array<T>;
             }
-
-            case A_CommonHelper.isInheritedFrom(component, A_Fragment): {
-                return this.resolveFragment(component as typeof A_Fragment) as InstanceType<T>;
+            case this.isFragmentConstructor(component): {
+                return this.resolveFragment(component) as T;
             }
-
-            case A_CommonHelper.isInheritedFrom(component, A_Scope): {
-                return this.resolveScope(component as typeof A_Scope) as InstanceType<T>;
+            case this.isCommandConstructor(component): {
+                return this.resolveCommand(component) as T;
             }
-
-            case A_CommonHelper.isInheritedFrom(component, A_Component): {
-                return this.resolveComponent(component as typeof A_Component) as InstanceType<T>;
+            case this.isScopeConstructor(component): {
+                return this.resolveScope(component) as T;
+            }
+            case this.isComponentConstructor(component): {
+                return this.resolveComponent(component) as T;
             }
-
             default:
                 throw new Error(`Injected Component ${component} not found in the scope`);
         }
     }
 
+    /**
+     * This method is used internally to resolve a single entity from the scope based on the provided instructions
+     * 
+     * [!] Note that this method can return either a single entity or an array of entities depending on the instructions provided
+     * 
+     * @param entity 
+     * @param instructions 
+     * @returns 
+     */
+    private resolveEntity<T extends A_Entity>(
+        entity: A_TYPES__AllowedEntitiesConstructor<T>,
+        instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>
+    ): T | Array<T> | undefined {
 
-    private resolveEntity<T extends { new(...args: any[]): A_Entity }>(
-        entity: T,
-        instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<InstanceType<T>>>
-    ): InstanceType<T> | undefined | InstanceType<T>[] {
-
-        const query = instructions?.query || {} as Partial<A_TYPES__A_InjectDecorator_EntityInjectionQuery<InstanceType<T>>>;
+        const query = instructions?.query || {} as Partial<A_TYPES__A_InjectDecorator_EntityInjectionQuery<T>>;
         const count = instructions?.pagination?.count || 1;
 
         switch (true) {
+            /**
+             * 1) In case when no instructions provided, return the first found entity of the provided type
+             * 
+             * [!] Note that it returns ONLY ONE entity
+             * [!!] In case when no entity found in the current scope, it tries to resolve it from the parent scope (if exists)
+             */
             case !instructions: {
-                const entities = Array.from(this._entities.values());
-
-                const found = entities.find(e => e instanceof entity);
+                const found = this.entities.find(e => e instanceof entity);
 
                 switch (true) {
                     case !!found:
-                        return found as InstanceType<T>;
+                        return found as T;
 
                     case !found && !!this._parent:
                         return this._parent.resolveEntity(entity, instructions);
@@ -486,74 +674,84 @@ export class A_Scope {
                         throw new Error(`Entity ${entity.name} not found in the scope ${this.name}`);
                 }
             }
-
+            /**
+             * 2) In case when aseid is provided in the query, we can directly get the entity from the map
+             * 
+             * [!] Note that it returns ONLY ONE entity
+             */
             case !!query.aseid
                 && typeof query.aseid === 'string'
                 && this._entities.has(query.aseid): {
-                    return this._entities.get(query.aseid) as InstanceType<T>;
+                    return this._entities.get(query.aseid) as T;
                 }
-
+            /**
+             * 3) In case when aseid is provided as ASEID instance, we can directly get the entity from the map
+             * 
+             * [!] Note that it returns ONLY ONE entity
+             */
             case !!query.aseid
                 && typeof query.aseid === 'object'
                 && query.aseid instanceof ASEID
                 && this._entities.has(query.aseid.toString()): {
-                    return this._entities.get(query.aseid.toString()) as InstanceType<T>;
+                    return this._entities.get(query.aseid.toString()) as T;
                 }
-
+            /**
+             * 4) In case when id is provided in the query, we have to find the entity by the id
+             * 
+             * [!]  Note that it returns ONLY ONE entity
+             */
             case !!query.id: {
 
-                // in this case we have to find the entity by the id
-                const entities = Array.from(this._entities.values());
-
-                const found = entities.filter(
-                    e => e instanceof entity
-                ).find(e => {
-                    return String(e.id) === String(query.id)
-                });
+                const found = this.entities
+                    .filter(e => e instanceof entity)
+                    .find(e => String(e.id) === String(query.id));
 
-                return found as InstanceType<T>;
+                return found as T;
             }
-
+            /**
+             * 5) In case when there's a query object, we have to filter the entities by the query
+             * 
+             * [!] Note that it can return either a single entity or an array of entities depending on the count instruction
+             * [!!] In case when no entity found in the current scope, it tries to resolve it from the parent scope (if exists)
+             */
             default: {
-                const entities = Array.from(this._entities.values());
-
-                const found = entities.filter(
-                    e => e instanceof entity
-                ).filter(e => {
-                    return Object.entries(query).every(([key, value]) => {
-                        if (key in e) {
-                            return (e as any)[key] === value;
-                        }
-                        return false;
+
+                const found = this.entities
+                    .filter(e => e instanceof entity)
+                    .filter(e => {
+                        return Object
+                            .entries(query)
+                            .every(([key, value]) => {
+                                if (key in e) {
+                                    return (e as any)[key] === value;
+                                }
+                                return false;
+                            });
                     });
-                });
 
                 if (found.length === 0 && !!this._parent)
                     return this._parent.resolveEntity(entity, instructions);
 
                 if (count === 1)
-                    return found[0] as InstanceType<T>;
+                    return found[0] as T;
 
-                return found as InstanceType<T>[];
+                return found as T[];
             }
-
         }
     }
 
-
-
-    private resolveFragment<T extends typeof A_Fragment>(fragment: T): InstanceType<T> {
-
-        const fragmentInstancePresented = this.fragments.some(fr => fr instanceof fragment);
-
+    /**
+     * This method is used internally to resolve a single fragment from the scope
+     * 
+     * @param fragment 
+     * @returns 
+     */
+    private resolveFragment<T extends A_Fragment>(fragment: A_TYPES__AllowedFragmentsConstructor<T>): _FragmentType[number] {
+        const fragmentInstancePresented = this._fragments.get(fragment);
 
         switch (true) {
-
             case fragmentInstancePresented && this._fragments.has(fragment):
-                return this._fragments.get(fragment);
-
-            case fragmentInstancePresented && !this._fragments.has(fragment):
-                return this.fragments.find(fr => fr instanceof fragment) as InstanceType<T>;
+                return fragmentInstancePresented;
 
             case !fragmentInstancePresented && !!this._parent:
                 return this._parent.resolveFragment(fragment);
@@ -562,28 +760,34 @@ export class A_Scope {
                 throw new Error(`Fragment ${fragment.name} not found in the scope ${this.name}`);
         }
     }
-
-
-    private resolveScope(scope: typeof A_Scope): A_Scope {
+    /**
+     *  This method is used internally to resolve a single scope from the current scope
+     * 
+     * @param scope 
+     * @returns 
+     */
+    private resolveScope(scope: A_TYPES__AllowedScopesConstructor): A_Scope {
         return this;
     }
-
-
-    private resolveComponent<T extends A_Component>(component: {
-        new(...args: any[]): T
-    }): T {
+    /**
+     * This method is used internally to resolve a single component from the scope
+     * 
+     * @param component 
+     * @returns 
+     */
+    private resolveComponent<T extends A_Component>(component: A_TYPES__AllowedComponentsConstructor<T>): InstanceType<_ComponentType[number]> {
 
         //  The idea here that in case when Scope has no exact component we have to resolve it from the _parent
         //  BUT: if it's not presented in _parent  we have to check for inheritance
         //  That means that we should ensure that there's no components that are children of the required component
         switch (true) {
-            // In case when the component is available and exists in the scope
-            case this.components.includes(component) && this._components.has(component): {
-                return this._components.get(component);
+            // 1) In case when the component is available and exists in the scope
+            case this.allowedComponents.has(component) && this._components.has(component): {
+                return this._components.get(component)!;
             }
 
-            // In case the component available but does NOT exist in the scope
-            case this.components.includes(component) && !this._components.has(component): {
+            // 2) In case the component available but does NOT exist in the scope
+            case this.allowedComponents.has(component) && !this._components.has(component): {
                 const componentMeta = A_Context.meta(component)
 
                 const argsMeta = componentMeta.get(A_TYPES__ComponentMetaKey.INJECTIONS);
@@ -597,53 +801,48 @@ export class A_Scope {
                                 instructions
                             );
                         }
-                        return this.resolve(arg.target)
+                        // TODO: Fix types mismatch here
+                        return this.resolve<T>(arg.target as any);
                     });
 
                 const newComponent = new component(...resolvedArgs)
 
                 this.register(newComponent);
 
-                return this._components.get(component);
+                return this._components.get(component)!;
             }
 
-            // In case when there's a component that is inherited from the required component
-            case !this.components.includes(component) && this.components.some(el => A_CommonHelper.isInheritedFrom(el, component)): {
-
-                const found = this.components.find(el => A_CommonHelper.isInheritedFrom(el, component));
+            // 3) In case when there's a component that is inherited from the required component
+            case !this.allowedComponents.has(component) && Array.from(this.allowedComponents).some(el => A_CommonHelper.isInheritedFrom(el, component)): {
+                const found = Array.from(this.allowedComponents).find(el => A_CommonHelper.isInheritedFrom(el, component))!;
 
-                return this.resolveComponent<T>(found as any);
+                return this.resolveComponent(found);
             }
 
-            // In case when the component is not available in the scope but the _parent is available
-            case !this.components.includes(component) && !!this._parent: {
-                return this._parent.resolveComponent(component);
+            // 4) In case when the component is not available in the scope but the _parent is available
+            case !!this._parent: {
+                return this._parent.resolveComponent(component) as InstanceType<_ComponentType[number]>;
             }
 
             default:
                 throw new Error(`Component ${component.name} not found in the scope ${this.name}`);
         }
     }
-
-
     /**
      * Should be similar to resolveEntity but for commands
      * 
      * @param command 
      */
-    private resolveCommand<T extends A_Command>(command: {
-        new(...args: any[]): T
-    }): T {
-        const commands = Array.from(this._commands.values());
+    private resolveCommand(command: _CommandType[number]): InstanceType<_CommandType[number]> {
 
-        const found = commands.find(e => e instanceof command);
+        const found = this.commands.find(e => e instanceof command);
 
         switch (true) {
             case !!found:
-                return found as T;
+                return found
 
             case !found && !!this._parent:
-                return this._parent.resolveCommand(command);
+                return this._parent.resolveCommand(command) as InstanceType<_CommandType[number]>;
 
             default:
                 throw new Error(`Command ${command.name} not found in the scope ${this.name}`);
@@ -657,86 +856,137 @@ export class A_Scope {
      * 
      * @param fragment 
      */
-    register<T extends A_Component>(component: new (...args: any[]) => T): void
-    register<T extends A_Entity>(entity: new (...args: any[]) => T): void
-    register<T extends A_Command>(command: new (...args: any[]) => T): void
-    register(entity: A_Entity): void
-    register(component: A_Component): void
-    register(fragment: A_Fragment): void
+    register<T extends A_Component>(
+        /**
+         * Provide a component constructor to register it in the scope
+         */
+        component: A_TYPES__AllowedComponentsConstructor<T>
+    ): void
+    register<T extends A_Entity>(
+        /**
+         * Provide an entity constructor to register it in the scope
+         */
+        entity: A_TYPES__AllowedEntitiesConstructor<T>
+    ): void
+    register<T extends A_Command>(
+        /**
+         * Provide a command constructor to register it in the scope
+         */
+        command: A_TYPES__AllowedCommandsConstructor<T>
+    ): void
+    register<T extends A_Fragment>(
+        /**
+         * Provide a command instance to register it in the scope
+         */
+        fragment: A_TYPES__AllowedFragmentsConstructor<T>
+    ): void
     register(
-        param1: A_Fragment
-            | A_Component
-            | A_Entity
-            | (new (...args: any[]) => A_Component)
-            | (new (...args: any[]) => A_Entity)
-            | (new (...args: any[]) => A_Command)
+        /**
+         * Provide an entity instance to register it in the scope
+         */
+        entity: A_Entity
+    ): void
+    register(
+        /**
+         * Provide a command instance to register it in the scope
+         */
+        component: A_Component
+    ): void
+    register(
+        /**
+         * Provide a command instance to register it in the scope
+         */
+        command: A_Command
+    ): void
+    register(
+        /**
+         * Provide a fragment instance to register it in the scope
+         */
+        fragment: A_Fragment
+    ): void
+    register(
+        param1: unknown
     ): void {
         switch (true) {
-            case param1 instanceof A_Component && !this._components.has(param1.constructor): {
-                this._components.set(param1.constructor, param1);
+            // ------------------------------------------
+            // ------------ Instances ----------------
+            // ------------------------------------------
+            // 1) In case when it's a A-Component instance
+            case param1 instanceof A_Component: {
 
-                const allowedComponent = this.components.find(c => c === param1.constructor);
+                if (!this.allowedComponents.has(param1.constructor as _ComponentType[number]))
+                    this.allowedComponents.add(param1.constructor as _ComponentType[number]);
 
-                if (!allowedComponent) {
-                    this.components.push(param1.constructor as any);
-                }
+                this._components.set(
+                    param1.constructor as _ComponentType[number],
+                    param1 as InstanceType<_ComponentType[number]>
+                );
 
                 A_Context.register(this, param1);
+
                 break;
             }
+            // 2) In case when it's a A-Command instance
+            case param1 instanceof A_Command: {
+
+                if (!this.allowedCommands.has(param1.constructor as _CommandType[number]))
+                    this.allowedCommands.add(param1.constructor as _CommandType[number]);
+
+                this._commands.set((param1 as any).constructor.code, param1 as InstanceType<_CommandType[number]>);
 
-            case param1 instanceof A_Entity && !this._entities.has(param1.aseid.toString()): {
-                this._entities.set(param1.aseid.toString(), param1);
                 A_Context.register(this, param1);
                 break;
             }
+            // 3) In case when it's a A-Entity instance
+            case param1 instanceof A_Entity && !this._entities.has(param1.aseid.toString()): {
 
-            case param1 instanceof A_Fragment && !this._fragments.has(param1.constructor): {
-                const allowedFragment = this.fragments.find(fr => fr instanceof param1.constructor);
-
-                if (!allowedFragment) {
-                    this.fragments.push(param1);
-                }
+                if (!this.allowedEntities.has(param1.constructor as A_TYPES__AllowedEntitiesConstructor<_EntityType[number]>))
+                    this.allowedEntities.add(param1.constructor as A_TYPES__AllowedEntitiesConstructor<_EntityType[number]>);
 
-                this._fragments.set(param1.constructor, param1);
+                this._entities.set(param1.aseid.toString(), param1);
                 A_Context.register(this, param1);
                 break;
             }
+            // 4) In case when it's a A-Fragment instance
+            case param1 instanceof A_Fragment: {
 
-            case param1 instanceof A_Component: {
-                this._components.set(param1.constructor, param1);
+                if (!this.allowedFragments.has(param1.constructor as A_TYPES__AllowedFragmentsConstructor<_FragmentType[number]>))
+                    this.allowedFragments.add(param1.constructor as A_TYPES__AllowedFragmentsConstructor<_FragmentType[number]>);
 
-                const allowedComponent = this.components.find(c => c === param1.constructor);
-
-                if (!allowedComponent) {
-                    this.components.push(param1.constructor as any);
-                }
+                this._fragments.set(
+                    param1.constructor as A_TYPES__AllowedFragmentsConstructor<_FragmentType[number]>,
+                    param1 as _FragmentType[number]
+                );
 
                 A_Context.register(this, param1);
+
                 break;
             }
-
-            case typeof param1 === 'function' && A_CommonHelper.isInheritedFrom(param1, A_Component): {
-                const allowedComponent = this.components.find(c => c === param1);
-
-                if (!allowedComponent)
-                    this.components.push(param1);
+            // ------------------------------------------
+            // ------------ Constructors ----------------
+            // ------------------------------------------
+            // 5) In case when it's a A-Component constructor
+            case this.isComponentConstructor(param1): {
+                if (!this.allowedComponents.has(param1))
+                    this.allowedComponents.add(param1 as _ComponentType[number]);
                 break;
             }
-            case typeof param1 === 'function' && A_CommonHelper.isInheritedFrom(param1, A_Entity): {
-                const allowedEntity = this.params.entities.find(e => e.constructor === param1);
-
-                if (!allowedEntity) {
-                    this.params.entities.push(new (param1 as any)());
-                }
+            // 6) In case when it's a A-Command constructor
+            case this.isCommandConstructor(param1): {
+                if (!this.allowedCommands.has(param1))
+                    this.allowedCommands.add(param1 as _CommandType[number]);
                 break;
             }
-            case typeof param1 === 'function' && A_CommonHelper.isInheritedFrom(param1, A_Command): {
-                const allowedCommand = this.commands.find(c => c === param1);
-
-                if (!allowedCommand) {
-                    this.commands.push(param1 as any);
-                }
+            // 7) In case when it's a A-Fragment constructor
+            case this.isFragmentConstructor(param1): {
+                if (!this.allowedFragments.has(param1))
+                    this.allowedFragments.add(param1 as A_TYPES__AllowedFragmentsConstructor<_FragmentType[number]>);
+                break;
+            }
+            // 8) In case when it's a A-Entity constructor
+            case this.isEntityConstructor(param1): {
+                if (!this.allowedEntities.has(param1))
+                    this.allowedEntities.add(param1 as A_TYPES__AllowedEntitiesConstructor<_EntityType[number]>);
                 break;
             }
 
@@ -748,23 +998,182 @@ export class A_Scope {
                 else
                     throw new Error(`Cannot register ${param1} in the scope ${this.name}`);
         }
+    }
+
+
+
 
+    /**
+     * This method is useful when you want to serialize the scope to JSON
+     * 
+     * [!] Note this is not a deep serialization, only the fragments are serialized
+     * [!] Fragments are a storage for information which is relevant to the scope
+     * 
+     * @returns 
+     */
+    toJSON(): Record<string, any> {
+        return this.fragments
+            .reduce((acc, fragment) => {
 
+                const serialized = fragment.toJSON()
 
+                return {
+                    ...acc,
+                    [serialized.name]: serialized
+                }
+            }, {});
+    }
+
+
+
+    //==========================================================================
+    // --------------------Scope Type Check Helpers---------------------------
+    //==========================================================================
+    /**
+     * Type guard to check if the constructor is of type A_Component
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    protected isComponentConstructor(ctor: unknown): ctor is A_TYPES__AllowedComponentsConstructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Component);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Command
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    protected isCommandConstructor(ctor: unknown): ctor is A_TYPES__AllowedCommandsConstructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Command);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Fragment
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    protected isFragmentConstructor(ctor: any): ctor is A_TYPES__AllowedFragmentsConstructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Fragment);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Entity
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    protected isEntityConstructor(ctor: unknown): ctor is A_TYPES__AllowedEntitiesConstructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Entity);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Scope
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    protected isScopeConstructor(ctor: unknown): ctor is A_TYPES__AllowedScopesConstructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Scope);
+    }
+    // -------------------------------------------------------------------------------
+    // --------------------Scope Allowed Type Check Helpers---------------------------
+    // -------------------------------------------------------------------------------
+    /**
+     * Type guard to check if the constructor is of type A_Component and is allowed in the scope
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    protected isAllowedComponent(ctor: unknown): ctor is _ComponentType[number] {
+        return this.isComponentConstructor(ctor) && this.allowedComponents.has(ctor);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Command and is allowed in the scope
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    protected isAllowedCommand(ctor: unknown): ctor is _CommandType[number] {
+        return this.isCommandConstructor(ctor) && this.allowedCommands.has(ctor);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Entity and is allowed in the scope
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    protected isAllowedEntity(ctor: unknown): ctor is A_TYPES__AllowedEntitiesConstructor<_EntityType[number]> {
+        return this.isEntityConstructor(ctor) && this.allowedEntities.has(ctor);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Fragment and is allowed in the scope
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    protected isAllowedFragment(ctor: unknown): ctor is A_TYPES__AllowedFragmentsConstructor<_FragmentType[number]> {
+        return this.isFragmentConstructor(ctor) && this.allowedFragments.has(ctor);
     }
 
 
 
 
-    toJSON(): Record<string, any> {
-        return this.fragments.reduce((acc, fragment) => {
+    // ==========================================================================
+    // --------------------DEBUG & Helpers Methods--------------------------------
+    // ===========================================================================
+    /**
+     * This method is used to check if the scope is inherited from another scope
+     * 
+     * @param scope 
+     * @returns 
+     */
+    isInheritedFrom(scope: A_Scope): boolean {
+        let current: A_Scope | undefined = this;
 
-            const serialized = fragment.toJSON()
+        while (current) {
+            if (current === scope) {
+                return true;
+            }
+            current = current._parent;
+        }
+
+        return false;
+    }
+
+    /**
+     * Helper method to check circular inheritance
+     * Should return a full sequence of inheritance for logging purposes
+     * 
+     * @param scope 
+     * @returns 
+     */
+    checkCircularInheritance(scope: A_Scope): Array<string> | false {
+        const inheritanceChain: Array<string> = [];
+        let current: A_Scope | undefined = this._parent;
 
-            return {
-                ...acc,
-                [serialized.name]: serialized
+        while (current) {
+            inheritanceChain.push(current.name);
+            if (current === scope) {
+                return inheritanceChain;
             }
-        }, {});
+            current = current._parent;
+        }
+
+        return false;
     }
-}
+
+    /**
+     * Helper method to print the inheritance chain of the scope
+     */
+    printInheritanceChain(): void {
+        const chain: Array<string> = [];
+        let current: A_Scope | undefined = this;
+
+        while (current) {
+            chain.push(current.name);
+            current = current._parent;
+        }
+
+        console.log(chain.join(' -> '));
+    }
+}
+