@adaas/a-concept 0.0.63 → 0.0.64

package/dist/src/global/A-Scope/A-Scope.class.js

@@ -2,176 +2,242 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.A_Scope = void 0;
 const a_utils_1 = require("@adaas/a-utils");
+const A_Component_types_1 = require("../A-Component/A-Component.types");
 const A_Fragment_class_1 = require("../A-Fragment/A-Fragment.class");
 const A_Context_class_1 = require("../A-Context/A-Context.class");
-const A_Component_types_1 = require("../A-Component/A-Component.types");
 const A_Component_class_1 = require("../A-Component/A-Component.class");
 const A_Entity_class_1 = require("../A-Entity/A-Entity.class");
 const A_Command_class_1 = require("../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.
- *
- *
- */
 class A_Scope {
+    // ===========================================================================
+    // --------------------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() { return Array.from(this._entities.values()); }
+    /**
+     * Returns an Array of fragments registered in the scope
+     *
+     * [!] One fragment per scope
+     */
+    get fragments() { return Array.from(this._fragments.values()); }
+    /**
+     * Returns an Array of components registered in the scope
+     *
+     * [!] One component instance per scope
+     */
+    get components() { 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() { return Array.from(this._commands.values()); }
+    /**
+     * 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, config = {}) {
+        /**
+         * Scope Name uses for identification and logging purposes
+         */
         this.name = '';
-        this._components = new WeakMap();
-        this._fragments = new WeakMap();
-        this._commands = new Map();
+        // ===========================================================================
+        // --------------------ALLowed Constructors--------------------------------
+        // ===========================================================================
+        /**
+         * A set of allowed components, A set of constructors that are allowed in the scope
+         *
+         */
+        this._allowedComponents = new Set();
+        /**
+         * A set of allowed entities, A set of constructors that are allowed in the scope
+         */
+        this._allowedEntities = new Set();
+        /**
+         * A set of allowed fragments, A set of constructors that are allowed in the scope
+         */
+        this._allowedFragments = new Set();
+        /**
+         * A set of allowed commands, A set of constructors that are allowed in the scope
+         */
+        this._allowedCommands = new Set();
+        // ===========================================================================
+        // --------------------Internal Storage--------------------------------
+        // ===========================================================================
+        /**
+         * Internal storage for the components, fragments, entities and commands
+         */
+        this._components = new Map();
+        /**
+         * Storage for the fragments, should be weak as fragments are singletons per scope
+         */
+        this._fragments = new Map();
+        /**
+         * Storage for the entities, should be strong as entities are unique per aseid
+         */
         this._entities = new Map();
+        /**
+         * Storage for the commands, should be strong as commands are unique per code
+         */
+        this._commands = new Map();
         this.name = params.name || this.constructor.name;
-        // TODO: move to defaults
-        const defaultParams = {
-            name: '',
-            components: [],
-            fragments: [],
-            entities: [],
-            commands: [],
-        };
-        this.params = Object.assign(Object.assign({}, defaultParams), params);
-        this.initComponents(params.components || []);
-        this.initFragments(params.fragments || []);
-        this.initEntities(params.entities || []);
+        this.initComponents(params.components);
+        this.initCommands(params.commands);
+        this.initFragments(params.fragments);
+        this.initEntities(params.entities);
         if (config.parent) {
             this._parent = config.parent;
         }
     }
-    initComponents(_components) {
-        // _components.forEach(component => {
-        //     this._components.set(component, new component());
-        // })
-    }
-    initEntities(_entities) {
-        _entities.forEach(this.register.bind(this));
-    }
-    initFragments(_fragments) {
-        _fragments.forEach(this.register.bind(this));
-    }
-    get components() {
-        return this.params.components || [];
-    }
-    get commands() {
-        return this.params.commands || [];
-    }
-    get fragments() {
-        return this.params.fragments || [];
-    }
+    //==========================================================================
+    // --------------------Scope Initialization Methods---------------------------
+    //==========================================================================
+    /**
+     * 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
+     */
+    initComponents(_components) { _components === null || _components === void 0 ? void 0 : _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
+     */
+    initEntities(_entities) { _entities === null || _entities === void 0 ? void 0 : _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
+     */
+    initFragments(_fragments) { _fragments === null || _fragments === void 0 ? void 0 : _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
+     */
+    initCommands(_commands) { _commands === null || _commands === void 0 ? void 0 : _commands.forEach(this.register.bind(this)); }
+    /**
+     * 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) {
         if (setValue) {
             return this.inherit(setValue);
         }
         return this._parent;
     }
-    isInheritedFrom(scope) {
-        let current = this;
-        while (current) {
-            if (current === scope) {
-                return true;
-            }
-            current = current._parent;
-        }
-        return false;
-    }
+    /**
+     * This method is used to inherit from a parent scope
+     *
+     * [!] This method checks for circular inheritance and throws an error if detected
+     *
+     * @param parent
+     * @returns
+     */
     inherit(parent) {
         // Prevent circular inheritance
         const circularCheck = this.checkCircularInheritance(parent);
-        if (circularCheck) {
-            throw new Error(`Circular inheritance detected: ${[...circularCheck, parent.name].join(' -> ')}`);
-        }
+        if (circularCheck)
+            throw new a_utils_1.A_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
-     *
-     * @param scope
-     * @returns
-     */
-    checkCircularInheritance(scope) {
-        const inheritanceChain = [];
-        let current = this._parent;
-        while (current) {
-            inheritanceChain.push(current.name);
-            if (current === scope) {
-                return inheritanceChain;
-            }
-            current = current._parent;
-        }
-        return false;
-    }
-    printInheritanceChain() {
-        const chain = [];
-        let current = this;
-        while (current) {
-            chain.push(current.name);
-            current = current._parent;
-        }
-        console.log(chain.join(' -> '));
-    }
-    has(entity) {
+    has(ctor) {
+        let found = false;
         switch (true) {
-            case typeof entity === 'string': {
-                const possibleComponent = this.params.components.find(c => c.name === entity);
-                if (possibleComponent) {
-                    return 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) 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;
+                // 1.2 Check if it's a fragment name
+                const possibleFragment = Array.from(this.allowedFragments).find(f => f.name === ctor);
+                if (possibleFragment)
+                    found = 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;
+                // 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;
             }
-            case typeof entity === 'function'
-                && a_utils_1.A_CommonHelper.isInheritedFrom(entity, A_Component_class_1.A_Component):
-                {
-                    const found = this.components.includes(entity);
-                    if (!found && !!this._parent) {
-                        return this._parent.has(entity);
-                    }
-                    return found;
-                }
-            case typeof entity === 'function'
-                && a_utils_1.A_CommonHelper.isInheritedFrom(entity, A_Entity_class_1.A_Entity):
-                {
-                    const entities = Array.from(this._entities.values());
-                    const found = entities.find(e => e instanceof entity);
-                    return !!found;
-                }
-            case typeof entity === 'function'
-                && a_utils_1.A_CommonHelper.isInheritedFrom(entity, A_Fragment_class_1.A_Fragment):
-                {
-                    const found = this._fragments.has(entity);
-                    if (!found && !!this._parent)
-                        return this._parent.has(entity);
-                    return found;
-                }
-            case typeof entity === 'function'
-                && a_utils_1.A_CommonHelper.isInheritedFrom(entity, A_Command_class_1.A_Command):
-                {
-                    const found = this.commands.includes(entity);
-                    if (!found && !!this._parent)
-                        return this._parent.has(entity);
-                    return found;
-                }
-            default: {
-                return false;
+            // 2) Check if it's a Component
+            case this.isComponentConstructor(ctor): {
+                found = this.isAllowedComponent(ctor);
+                break;
+            }
+            // 3) Check if it's an Entity
+            case this.isEntityConstructor(ctor): {
+                found = this.isAllowedEntity(ctor);
+                break;
+            }
+            // 4) Check if it's a Fragment
+            case this.isFragmentConstructor(ctor): {
+                found = this.isAllowedFragment(ctor);
+                break;
+            }
+            // 5) Check if it's a Command
+            case this.isCommandConstructor(ctor): {
+                found = this.isAllowedCommand(ctor);
+                break;
             }
         }
+        if (!found && !!this._parent)
+            return this._parent.has(ctor);
+        return found;
     }
     /**
      * Merges two scopes into a new one
@@ -185,52 +251,40 @@ class A_Scope {
      */
     merge(anotherScope) {
         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
         });
         return merged;
     }
-    /**
-     * Allows to retrieve the constructor of the component or entity by its name
-     *
-     * [!] Notes:
-     * - In case of search for A-Entity please ensure that provided string corresponds to the static entity property of the class. [!] By default it's the kebab-case of the class name
-     * - In case of search for A_Command please ensure that provided string corresponds to the static code property of the class. [!] By default it's the kebab-case of the class name
-     * - In case of search for A_Component please ensure that provided string corresponds to the class name in PascalCase
-     *
-     * @param name
-     * @returns
-     */
     resolveConstructor(name) {
-        // Check components
-        const component = this.params.components.find(c => c.name === a_utils_1.A_CommonHelper.toPascalCase(name));
+        // 1) Check components
+        const component = Array.from(this.allowedComponents).find(c => c.name === name
+            || c.name === a_utils_1.A_CommonHelper.toPascalCase(name));
         if (component)
             return component;
-        // Check entities
-        const entity = this.params.entities.find(e => e.constructor.entity === name
-            || e.constructor.name === a_utils_1.A_CommonHelper.toPascalCase(name)
-            || e.constructor.entity === a_utils_1.A_CommonHelper.toKebabCase(name));
+        // 2) Check entities
+        const entity = Array.from(this.allowedEntities).find(e => e.name === name
+            || e.name === a_utils_1.A_CommonHelper.toPascalCase(name)
+            || e.entity === name
+            || e.entity === a_utils_1.A_CommonHelper.toKebabCase(name));
         if (entity)
-            return entity.constructor;
-        // Check commands 
-        const command = this.params.commands.find(c => c.code === name
+            return entity;
+        // 3) Check commands
+        const command = Array.from(this.allowedCommands).find(c => c.code === name
             || c.name === a_utils_1.A_CommonHelper.toPascalCase(name)
             || c.code === a_utils_1.A_CommonHelper.toKebabCase(name));
         if (command)
             return command;
+        // 4) Check fragments
+        const fragment = Array.from(this.allowedFragments).find(f => f.name === name
+            || f.name === a_utils_1.A_CommonHelper.toPascalCase(name));
+        if (fragment)
+            return fragment;
         // If not found in current scope, check parent scope
         if (!!this._parent) {
             return this._parent.resolveConstructor(name);
@@ -238,10 +292,14 @@ class A_Scope {
         throw new Error(`Component or Entity with name ${name} not found in the scope ${this.name}`);
     }
     // base definition
-    resolve(param1, param2) {
+    resolve(
+    /**
+     * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
+     */
+    param1, param2) {
         switch (true) {
             case Array.isArray(param1): {
-                return param1.map(c => this.resolveOnce(param1, param2));
+                return param1.map(c => this.resolveOnce(c, param2)).filter(Boolean);
             }
             case typeof param1 === 'function': {
                 return this.resolveOnce(param1, param2);
@@ -250,59 +308,99 @@ class A_Scope {
                 return this.resolveByName(param1);
             }
             default: {
-                throw new Error('Invalid arguments provided');
+                throw new a_utils_1.A_Error(`Invalid parameter provided to resolve method: ${param1} in scope ${this.name}`);
             }
         }
     }
+    // ==================================================================================================
+    // --------------------------------------------------------------------------------------------------
+    // -------------------------------------INTERNAL RESOLVERS-------------------------------------------
+    // --------------------------------------------------------------------------------------------------
+    // ==================================================================================================
     resolveByName(name) {
-        // Check components
-        const component = this.params.components.find(c => c.name === name);
+        // 1) Check components
+        const component = Array.from(this.allowedComponents).find(c => c.name === name
+            || c.name === a_utils_1.A_CommonHelper.toPascalCase(name));
         if (component)
-            return this.resolveComponent(component);
-        // Check commands
-        const command = this.params.commands.find(c => c.name === name);
+            return this.resolveOnce(component);
+        // 2) Check entities
+        const entity = Array.from(this.allowedEntities).find(e => e.name === name
+            || e.name === a_utils_1.A_CommonHelper.toPascalCase(name)
+            || e.entity === name
+            || e.entity === a_utils_1.A_CommonHelper.toKebabCase(name));
+        if (entity)
+            return this.resolveOnce(entity);
+        // 3) Check commands
+        const command = Array.from(this.allowedCommands).find(c => c.code === name
+            || c.name === a_utils_1.A_CommonHelper.toPascalCase(name)
+            || c.code === a_utils_1.A_CommonHelper.toKebabCase(name));
         if (command)
-            return this.resolveComponent(command);
-        // Check fragments
-        const fragment = this.params.fragments.find(f => f.constructor.name === name);
+            return this.resolveOnce(command);
+        // 4) Check fragments
+        const fragment = Array.from(this.allowedFragments).find(f => f.name === name
+            || f.name === a_utils_1.A_CommonHelper.toPascalCase(name));
         if (fragment)
-            return this.resolveFragment(fragment.constructor);
-        // Check entities
-        const entity = this.params.entities.find(e => e.constructor.name === name);
-        if (entity)
-            return this.resolveEntity(entity.constructor);
+            return this.resolveOnce(fragment);
         // If not found in current scope, check parent scope
-        if (this._parent) {
+        if (!!this._parent) {
             return this._parent.resolveByName(name);
         }
-        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}`);
     }
+    /**
+     * This method is used internally to resolve a single component, fragment or entity from the scope
+     *
+     * @param component
+     * @param instructions
+     * @returns
+     */
     resolveOnce(component, instructions) {
+        if (this.isScopeConstructor(component))
+            component;
+        if (typeof component == 'function' && component.name === 'A_Scope')
+            component;
         switch (true) {
-            case a_utils_1.A_CommonHelper.isInheritedFrom(component, A_Entity_class_1.A_Entity): {
+            case this.isEntityConstructor(component): {
                 return this.resolveEntity(component, instructions);
             }
-            case a_utils_1.A_CommonHelper.isInheritedFrom(component, A_Fragment_class_1.A_Fragment): {
+            case this.isFragmentConstructor(component): {
                 return this.resolveFragment(component);
             }
-            case a_utils_1.A_CommonHelper.isInheritedFrom(component, A_Scope): {
+            case this.isCommandConstructor(component): {
+                return this.resolveCommand(component);
+            }
+            case this.isScopeConstructor(component): {
                 return this.resolveScope(component);
             }
-            case a_utils_1.A_CommonHelper.isInheritedFrom(component, A_Component_class_1.A_Component): {
+            case this.isComponentConstructor(component): {
                 return this.resolveComponent(component);
             }
             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
+     */
     resolveEntity(entity, instructions) {
         var _a;
         const query = (instructions === null || instructions === void 0 ? void 0 : instructions.query) || {};
         const count = ((_a = instructions === null || instructions === void 0 ? void 0 : instructions.pagination) === null || _a === void 0 ? void 0 : _a.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;
@@ -312,12 +410,22 @@ 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);
                 }
+            /**
+             * 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 a_utils_1.ASEID
@@ -325,18 +433,30 @@ class A_Scope {
                 {
                     return this._entities.get(query.aseid.toString());
                 }
+            /**
+             * 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;
             }
+            /**
+             * 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]) => {
+                const found = this.entities
+                    .filter(e => e instanceof entity)
+                    .filter(e => {
+                    return Object
+                        .entries(query)
+                        .every(([key, value]) => {
                         if (key in e) {
                             return e[key] === value;
                         }
@@ -351,33 +471,49 @@ class A_Scope {
             }
         }
     }
+    /**
+     * This method is used internally to resolve a single fragment from the scope
+     *
+     * @param fragment
+     * @returns
+     */
     resolveFragment(fragment) {
-        const fragmentInstancePresented = this.fragments.some(fr => fr instanceof fragment);
+        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);
+                return fragmentInstancePresented;
             case !fragmentInstancePresented && !!this._parent:
                 return this._parent.resolveFragment(fragment);
             default:
                 throw new Error(`Fragment ${fragment.name} not found in the scope ${this.name}`);
         }
     }
+    /**
+     *  This method is used internally to resolve a single scope from the current scope
+     *
+     * @param scope
+     * @returns
+     */
     resolveScope(scope) {
         return this;
     }
+    /**
+     * This method is used internally to resolve a single component from the scope
+     *
+     * @param component
+     * @returns
+     */
     resolveComponent(component) {
         //  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): {
+            // 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_class_1.A_Context.meta(component);
                 const argsMeta = componentMeta.get(A_Component_types_1.A_TYPES__ComponentMetaKey.INJECTIONS);
                 const resolvedArgs = ((argsMeta === null || argsMeta === void 0 ? void 0 : argsMeta.get('constructor')) || [])
@@ -386,19 +522,20 @@ class A_Scope {
                         const { target, instructions } = arg;
                         return this.resolve(target, instructions);
                     }
+                    // TODO: Fix types mismatch here
                     return this.resolve(arg.target);
                 });
                 const newComponent = new component(...resolvedArgs);
                 this.register(newComponent);
                 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_utils_1.A_CommonHelper.isInheritedFrom(el, component)): {
-                const found = this.components.find(el => a_utils_1.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_utils_1.A_CommonHelper.isInheritedFrom(el, component)): {
+                const found = Array.from(this.allowedComponents).find(el => a_utils_1.A_CommonHelper.isInheritedFrom(el, component));
                 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: {
+            // 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);
             }
             default:
@@ -411,8 +548,7 @@ class A_Scope {
      * @param command
      */
     resolveCommand(command) {
-        const commands = Array.from(this._commands.values());
-        const found = commands.find(e => e instanceof command);
+        const found = this.commands.find(e => e instanceof command);
         switch (true) {
             case !!found:
                 return found;
@@ -424,56 +560,66 @@ class A_Scope {
     }
     register(param1) {
         switch (true) {
-            case param1 instanceof A_Component_class_1.A_Component && !this._components.has(param1.constructor): {
+            // ------------------------------------------
+            // ------------ Instances ----------------
+            // ------------------------------------------
+            // 1) In case when it's a A-Component instance
+            case param1 instanceof A_Component_class_1.A_Component: {
+                if (!this.allowedComponents.has(param1.constructor))
+                    this.allowedComponents.add(param1.constructor);
                 this._components.set(param1.constructor, param1);
-                const allowedComponent = this.components.find(c => c === param1.constructor);
-                if (!allowedComponent) {
-                    this.components.push(param1.constructor);
-                }
                 A_Context_class_1.A_Context.register(this, param1);
                 break;
             }
+            // 2) In case when it's a A-Command instance
+            case param1 instanceof A_Command_class_1.A_Command: {
+                if (!this.allowedCommands.has(param1.constructor))
+                    this.allowedCommands.add(param1.constructor);
+                this._commands.set(param1.constructor.code, param1);
+                A_Context_class_1.A_Context.register(this, param1);
+                break;
+            }
+            // 3) In case when it's a A-Entity instance
             case param1 instanceof A_Entity_class_1.A_Entity && !this._entities.has(param1.aseid.toString()): {
+                if (!this.allowedEntities.has(param1.constructor))
+                    this.allowedEntities.add(param1.constructor);
                 this._entities.set(param1.aseid.toString(), param1);
                 A_Context_class_1.A_Context.register(this, param1);
                 break;
             }
-            case param1 instanceof A_Fragment_class_1.A_Fragment && !this._fragments.has(param1.constructor): {
-                const allowedFragment = this.fragments.find(fr => fr instanceof param1.constructor);
-                if (!allowedFragment) {
-                    this.fragments.push(param1);
-                }
+            // 4) In case when it's a A-Fragment instance
+            case param1 instanceof A_Fragment_class_1.A_Fragment: {
+                if (!this.allowedFragments.has(param1.constructor))
+                    this.allowedFragments.add(param1.constructor);
                 this._fragments.set(param1.constructor, param1);
                 A_Context_class_1.A_Context.register(this, param1);
                 break;
             }
-            case param1 instanceof A_Component_class_1.A_Component: {
-                this._components.set(param1.constructor, param1);
-                const allowedComponent = this.components.find(c => c === param1.constructor);
-                if (!allowedComponent) {
-                    this.components.push(param1.constructor);
-                }
-                A_Context_class_1.A_Context.register(this, 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);
                 break;
             }
-            case typeof param1 === 'function' && a_utils_1.A_CommonHelper.isInheritedFrom(param1, A_Component_class_1.A_Component): {
-                const allowedComponent = this.components.find(c => c === param1);
-                if (!allowedComponent)
-                    this.components.push(param1);
+            // 6) In case when it's a A-Command constructor
+            case this.isCommandConstructor(param1): {
+                if (!this.allowedCommands.has(param1))
+                    this.allowedCommands.add(param1);
                 break;
             }
-            case typeof param1 === 'function' && a_utils_1.A_CommonHelper.isInheritedFrom(param1, A_Entity_class_1.A_Entity): {
-                const allowedEntity = this.params.entities.find(e => e.constructor === param1);
-                if (!allowedEntity) {
-                    this.params.entities.push(new param1());
-                }
+            // 7) In case when it's a A-Fragment constructor
+            case this.isFragmentConstructor(param1): {
+                if (!this.allowedFragments.has(param1))
+                    this.allowedFragments.add(param1);
                 break;
             }
-            case typeof param1 === 'function' && a_utils_1.A_CommonHelper.isInheritedFrom(param1, A_Command_class_1.A_Command): {
-                const allowedCommand = this.commands.find(c => c === param1);
-                if (!allowedCommand) {
-                    this.commands.push(param1);
-                }
+            // 8) In case when it's a A-Entity constructor
+            case this.isEntityConstructor(param1): {
+                if (!this.allowedEntities.has(param1))
+                    this.allowedEntities.add(param1);
                 break;
             }
             default:
@@ -485,12 +631,158 @@ class A_Scope {
                     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() {
-        return this.fragments.reduce((acc, fragment) => {
+        return this.fragments
+            .reduce((acc, fragment) => {
             const serialized = fragment.toJSON();
             return Object.assign(Object.assign({}, acc), { [serialized.name]: serialized });
         }, {});
     }
+    //==========================================================================
+    // --------------------Scope Type Check Helpers---------------------------
+    //==========================================================================
+    /**
+     * Type guard to check if the constructor is of type A_Component
+     *
+     * @param ctor
+     * @returns
+     */
+    isComponentConstructor(ctor) {
+        return typeof ctor === 'function' && a_utils_1.A_CommonHelper.isInheritedFrom(ctor, A_Component_class_1.A_Component);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Command
+     *
+     * @param ctor
+     * @returns
+     */
+    isCommandConstructor(ctor) {
+        return typeof ctor === 'function' && a_utils_1.A_CommonHelper.isInheritedFrom(ctor, A_Command_class_1.A_Command);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Fragment
+     *
+     * @param ctor
+     * @returns
+     */
+    isFragmentConstructor(ctor) {
+        return typeof ctor === 'function' && a_utils_1.A_CommonHelper.isInheritedFrom(ctor, A_Fragment_class_1.A_Fragment);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Entity
+     *
+     * @param ctor
+     * @returns
+     */
+    isEntityConstructor(ctor) {
+        return typeof ctor === 'function' && a_utils_1.A_CommonHelper.isInheritedFrom(ctor, A_Entity_class_1.A_Entity);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Scope
+     *
+     * @param ctor
+     * @returns
+     */
+    isScopeConstructor(ctor) {
+        return typeof ctor === 'function' && a_utils_1.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
+     */
+    isAllowedComponent(ctor) {
+        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
+     */
+    isAllowedCommand(ctor) {
+        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
+     */
+    isAllowedEntity(ctor) {
+        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
+     */
+    isAllowedFragment(ctor) {
+        return this.isFragmentConstructor(ctor) && this.allowedFragments.has(ctor);
+    }
+    // ==========================================================================
+    // --------------------DEBUG & Helpers Methods--------------------------------
+    // ===========================================================================
+    /**
+     * This method is used to check if the scope is inherited from another scope
+     *
+     * @param scope
+     * @returns
+     */
+    isInheritedFrom(scope) {
+        let current = this;
+        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) {
+        const inheritanceChain = [];
+        let current = this._parent;
+        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() {
+        const chain = [];
+        let current = this;
+        while (current) {
+            chain.push(current.name);
+            current = current._parent;
+        }
+        console.log(chain.join(' -> '));
+    }
 }
 exports.A_Scope = A_Scope;
 //# sourceMappingURL=A-Scope.class.js.map